diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/Example.scala b/src/main/scala/de/retest/guistatemachine/api/example/Example.scala similarity index 92% rename from src/main/scala/de/retest/guistatemachine/api/neo4j/Example.scala rename to src/main/scala/de/retest/guistatemachine/api/example/Example.scala index 39c0985..d5c2303 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/Example.scala +++ b/src/main/scala/de/retest/guistatemachine/api/example/Example.scala @@ -1,4 +1,5 @@ -package de.retest.guistatemachine.api.neo4j +package de.retest.guistatemachine.api.example + import java.util.Arrays import de.retest.guistatemachine.api.GuiStateMachineApi @@ -48,7 +49,7 @@ object Example extends App { "My Window" ) if (numberOfContainedComponents > 0) { - r.addChildren(scala.collection.JavaConverters.seqAsJavaList[Element](0 to numberOfContainedComponents map { _ => + r.addChildren(scala.collection.JavaConversions.seqAsJavaList[Element](0 to numberOfContainedComponents map { _ => getRootElement("x", 0) })) } diff --git a/src/main/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachinGMLSerializer.scala b/src/main/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachinGMLSerializer.scala index 25a56dd..a9daab4 100644 --- a/src/main/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachinGMLSerializer.scala +++ b/src/main/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachinGMLSerializer.scala @@ -24,10 +24,7 @@ class GuiStateMachinGMLSerializer(guiStateMachine: GuiStateMachine) extends GuiS // get the gml writer val writer = - new YedGmlWriter.Builder[SutStateIdentifier, GraphActionEdge, AnyRef](graphicsProvider, YedGmlWriter.PRINT_LABELS: _*) - .setEdgeLabelProvider(_.toString) - .setVertexLabelProvider(_.toString) - .build + new YedGmlWriter.Builder[SutStateIdentifier, GraphActionEdge, AnyRef](graphicsProvider, YedGmlWriter.PRINT_LABELS: _*).build // write to file val outputFile = new File(filePath) diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionConverter.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionConverter.scala deleted file mode 100644 index 3fc9b20..0000000 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionConverter.scala +++ /dev/null @@ -1,111 +0,0 @@ -package de.retest.guistatemachine.api.neo4j - -import de.retest.recheck.ui.descriptors.{Element, SutState} -import de.retest.surili.commons.actions._ -import org.neo4j.ogm.typeconversion.AttributeConverter - -import scala.collection.JavaConverters._ -import scala.xml._ - -/** - * We do not want to store the whole target element as XML again. Hence, we store its retest ID which is unique and - * matches the element in the SUT state and only the additional attributes. - */ -class ActionConverter(val sutState: Option[SutState]) extends AttributeConverter[Action, String] { - - def this() = this(None) - - def toGraphProperty(value: Action): String = { - val nodeBuffer = new NodeBuffer - - nodeBuffer += {value.getClass.getSimpleName} - - if (value.getTargetElement.isPresent) { - val retestId = value.getTargetElement.get().getRetestId - nodeBuffer += {retestId} - } - - value match { - case a: ChangeValueOfAction => - val sequences = a.getKeysToSend map { sequence => - {sequence.toString} - } - nodeBuffer += {sequences} - case a: NavigateToAction => - nodeBuffer += {a.getUrl} - case a: SwitchToWindowAction => - nodeBuffer += {a.getWindowName} - case _ => - } - - val topLevelNode = {nodeBuffer} - val stringBuilder = new StringBuilder("\n") - val prettyPrinter = new PrettyPrinter(0, 2) - prettyPrinter.formatNodes(topLevelNode, TopScope, stringBuilder) - stringBuilder.toString() - } - def toEntityAttribute(value: String): Action = sutState match { - case Some(state) => - val node = scala.xml.XML.loadString(value) - val typeNode = getNodeByTag(node, "type") - typeNode.text match { - case "ChangeValueOfAction" => - val element = getElement(node, state) - val keys = getNodeByTag(node, "keys") - val sequences = keys.child map { c => - c.text - } - new ChangeValueOfAction(element, sequences.toArray) - case "ClickOnAction" => - val element = getElement(node, state) - new ClickOnAction(element) - case "NavigateToAction" => - val urlNode = getNodeByTag(node, "url") - new NavigateToAction(urlNode.text) - case "NavigateBackAction" => new NavigateBackAction - case "NavigateForwardAction" => new NavigateForwardAction - case "NavigateRefreshAction" => new NavigateRefreshAction - case "SwitchToWindowAction" => - val windowNode = getNodeByTag(node, "window") - new SwitchToWindowAction(windowNode.text) - case _ => throw new RuntimeException("Unknown type.") - } - - case None => throw new RuntimeException("We need the SutState to reconstruct the action") - } - - private def getNodeByTag(node: Node, tag: String): Node = { - val matchingNodes = node \\ tag - if (matchingNodes.isEmpty) { - throw new RuntimeException(s"Missing node with tag $tag.") - } else { - matchingNodes.head - } - } - - private def getElement(node: Node, sutState: SutState): Element = { - val retestId = getNodeByTag(node, "retestId").text - getElementByRetestId(retestId, sutState) match { - case Some(element) => element - case None => throw new RuntimeException(s"Missing element with retestId $retestId") - } - } - - private def getElementByRetestId(retestId: String, sutState: SutState): Option[Element] = { - val elements = asScalaBuffer(sutState.getRootElements).toBuffer[Element] - val iterator = elements.iterator - var result: Option[Element] = None - - while (iterator.hasNext && result.isEmpty) { - val element = iterator.next() - result = if (element.getRetestId == retestId) { - Some(element) - } else { - elements ++= asScalaBuffer(element.getContainedElements) - None - } - } - - result - } -} diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionTransitionEntity.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionTransitionEntity.scala index 2e16baa..c927ed0 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionTransitionEntity.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/ActionTransitionEntity.scala @@ -1,23 +1,17 @@ package de.retest.guistatemachine.api.neo4j -import de.retest.recheck.ui.descriptors.SutState -import de.retest.surili.commons.actions.Action import org.neo4j.ogm.annotation.{EndNode, Index, RelationshipEntity, StartNode} @RelationshipEntity(`type` = "ACTIONS") -class ActionTransitionEntity(s: SutState, e: SutState, a: Action) extends Entity { - - def this() = this(null, null, null) +class ActionTransitionEntity(s: SutStateEntity, e: SutStateEntity, a: String) extends Entity { @Index - @StartNode val start: SutState = s + @StartNode val start: SutStateEntity = s @Index - @EndNode val end: SutState = e + @EndNode val end: SutStateEntity = e @Index - // TODO #19 We need the previous SutState for the conversion back to the action since we rely on the retest ID only to keep the action small. - //@Convert(classOf[ActionConverter]) - val actionXML: String = new ActionConverter().toGraphProperty(a) + val action: String = a /// The number of times this action has been executed. var counter: Int = 1 diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/Entity.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/Entity.scala index 8779963..9ea1588 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/Entity.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/Entity.scala @@ -4,5 +4,5 @@ import org.neo4j.ogm.annotation.{GeneratedValue, Id} abstract class Entity { @Id @GeneratedValue private val id = 0L - def getId: Long = id + def getId: java.lang.Long = id } diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineApiNeo4J.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineApiNeo4J.scala index 4afc579..9b51fd9 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineApiNeo4J.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineApiNeo4J.scala @@ -3,13 +3,12 @@ package de.retest.guistatemachine.api.neo4j import java.io.File import com.typesafe.scalalogging.Logger -import de.retest.guistatemachine.api.impl.GuiStateMachineImpl import de.retest.guistatemachine.api.{GuiStateMachine, GuiStateMachineApi} import scala.collection.concurrent.TrieMap class GuiStateMachineApiNeo4J extends GuiStateMachineApi { - private val logger = Logger[GuiStateMachineImpl] + private val logger = Logger[GuiStateMachineApiNeo4J] private val stateMachines = TrieMap[String, GuiStateMachine]() // TODO #19 Load existing state machines from the disk. diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineNeo4J.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineNeo4J.scala index a0f225f..12fe48f 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineNeo4J.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/GuiStateMachineNeo4J.scala @@ -1,8 +1,6 @@ package de.retest.guistatemachine.api.neo4j -import de.retest.guistatemachine.api.{GuiStateMachine, State} -import de.retest.recheck.ui.descriptors.SutState -import de.retest.surili.commons.actions.Action +import de.retest.guistatemachine.api.{GuiStateMachine, State, SutStateIdentifier} import org.neo4j.ogm.cypher.{ComparisonOperator, Filter} import scala.collection.immutable.HashMap @@ -10,44 +8,36 @@ import scala.collection.immutable.HashMap class GuiStateMachineNeo4J(var uri: String) extends GuiStateMachine { implicit val session = Neo4jSessionFactory.getSessionFactory(uri).openSession() // TODO #19 Close the session at some point? - override def getState(sutState: SutState): State = { + override def getState(sutStateIdentifier: SutStateIdentifier): State = { Neo4jSessionFactory.transaction { - getNodeBySutState(sutState) match { + getNodeBySutStateIdentifier(sutStateIdentifier) match { case None => // Create a new node for the SUT state in the graph database. - session.save(new SutStateEntity(sutState)) + val sutStateEntity = new SutStateEntity(sutStateIdentifier) + session.save(sutStateEntity) // Do nothing if the node for the SUT state does already exist. case _ => } } - StateNeo4J(sutState, this) + StateNeo4J(sutStateIdentifier, this) } - override def executeAction(from: State, a: Action, to: State): State = { - from.addTransition(a, to) - to - } - - override def getAllStates: Map[SutState, State] = + override def getAllStates: Map[SutStateIdentifier, State] = Neo4jSessionFactory.transaction { val allNodes = session.loadAll(classOf[SutStateEntity]) - var result = HashMap[SutState, State]() + var result = HashMap[SutStateIdentifier, State]() val iterator = allNodes.iterator() while (iterator.hasNext) { val node = iterator.next() - val sutState = node.sutState + val sutState = new SutStateIdentifier(node.id) result = result + (sutState -> StateNeo4J(sutState, this)) } result } - override def getAllExploredActions: Set[Action] = Set() // TODO #19 get all relationships in a transaction - - override def getActionExecutionTimes: Map[Action, Int] = Map() // TODO #19 get all execution time properties "counter" from all actions - override def clear(): Unit = Neo4jSessionFactory.transaction { // Deletes all nodes and relationships. @@ -61,10 +51,8 @@ class GuiStateMachineNeo4J(var uri: String) extends GuiStateMachine { uri = otherStateMachine.uri } - // TODO #19 Create an index on the property "sutState": https://neo4j.com/docs/cypher-manual/current/schema/index/#schema-index-create-a-single-property-index - // TODO #19 Should always be used inside of a transaction. - private[neo4j] def getNodeBySutState(sutState: SutState): Option[SutStateEntity] = { - val filter = new Filter("sutState", ComparisonOperator.EQUALS, sutState) // TODO #19 Is this how we filter for an attribute? + private[neo4j] def getNodeBySutStateIdentifier(sutStateIdentifier: SutStateIdentifier): Option[SutStateEntity] = { + val filter = new Filter("id", ComparisonOperator.EQUALS, sutStateIdentifier.hash) val first = session.loadAll(classOf[SutStateEntity], filter).stream().findFirst() if (first.isPresent) { Some(first.get()) diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/Neo4jSessionFactory.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/Neo4jSessionFactory.scala index c5c4f5a..2d22150 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/Neo4jSessionFactory.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/Neo4jSessionFactory.scala @@ -13,7 +13,7 @@ object Neo4jSessionFactory { case Some(sessionFactory) => sessionFactory case None => val conf = new Configuration.Builder().uri(uri).build - val sessionFactory = new SessionFactory(conf, "de.retest.guistatemachine.api.neo4j") + val sessionFactory = new SessionFactory(conf, this.getClass.getPackage.getName) sessionFactories += (uri -> sessionFactory) sessionFactory } diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/StateNeo4J.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/StateNeo4J.scala index 170b87d..729fa94 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/StateNeo4J.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/StateNeo4J.scala @@ -1,25 +1,24 @@ package de.retest.guistatemachine.api.neo4j -import de.retest.guistatemachine.api.{ActionTransitions, State} -import de.retest.recheck.ui.descriptors.SutState -import de.retest.surili.commons.actions.Action +import de.retest.guistatemachine.api.{ActionIdentifier, ActionTransitions, State, SutStateIdentifier} import org.neo4j.ogm.cypher.{ComparisonOperator, Filter} import scala.collection.immutable.HashMap -case class StateNeo4J(sutState: SutState, guiStateMachine: GuiStateMachineNeo4J) extends State { +case class StateNeo4J(sutStateIdentifier: SutStateIdentifier, guiStateMachine: GuiStateMachineNeo4J) extends State { implicit val session = guiStateMachine.session - override def getSutState: SutState = sutState - override def getOutgoingActionTransitions: Map[Action, ActionTransitions] = + override def getSutStateIdentifier: SutStateIdentifier = sutStateIdentifier + // TODO #19 Can we somehow convert the outgoing relations directly from the SutStateEntity? + override def getOutgoingActionTransitions: Map[ActionIdentifier, ActionTransitions] = Neo4jSessionFactory.transaction { - val filter = new Filter("start", ComparisonOperator.EQUALS, sutState) + val filter = new Filter("start", ComparisonOperator.EQUALS, sutStateIdentifier.hash) val transitions = session.loadAll(classOf[ActionTransitionEntity], filter) - var result = HashMap[Action, ActionTransitions]() + var result = HashMap[ActionIdentifier, ActionTransitions]() val iterator = transitions.iterator() while (iterator.hasNext) { val relationship = iterator.next() - val action = new ActionConverter(Some(relationship.start)).toEntityAttribute(relationship.actionXML) - val targetSutState = relationship.end + val action = new ActionIdentifier(relationship.action) + val targetSutState = new SutStateIdentifier(relationship.end.id) val counter = relationship.counter val actionTransitions = if (result.contains(action)) { val existing = result(action) @@ -31,16 +30,16 @@ case class StateNeo4J(sutState: SutState, guiStateMachine: GuiStateMachineNeo4J) } result } - - def getIncomingActionTransitions: Map[Action, ActionTransitions] = Neo4jSessionFactory.transaction { - val filter = new Filter("end", ComparisonOperator.EQUALS, sutState) + // TODO #19 Can we somehow convert the incoming relations directly from the SutStateEntity? + def getIncomingActionTransitions: Map[ActionIdentifier, ActionTransitions] = Neo4jSessionFactory.transaction { + val filter = new Filter("end", ComparisonOperator.EQUALS, sutStateIdentifier.hash) val transitions = session.loadAll(classOf[ActionTransitionEntity], filter) - var result = HashMap[Action, ActionTransitions]() + var result = HashMap[ActionIdentifier, ActionTransitions]() val iterator = transitions.iterator() while (iterator.hasNext) { val relationship = iterator.next() - val action = new ActionConverter(Some(relationship.start)).toEntityAttribute(relationship.actionXML) - val sourceSutState = relationship.start + val action = new ActionIdentifier(relationship.action) + val sourceSutState = new SutStateIdentifier(relationship.start.id) val counter = relationship.counter val actionTransitions = if (result.contains(action)) { val existing = result(action) @@ -53,22 +52,33 @@ case class StateNeo4J(sutState: SutState, guiStateMachine: GuiStateMachineNeo4J) result } - private[api] override def addTransition(a: Action, to: State): Int = Neo4jSessionFactory.transaction { - val filterStart = new Filter("start", ComparisonOperator.EQUALS, sutState) - val filterAction = new Filter("action", ComparisonOperator.EQUALS, a) - val targetSutState = to.asInstanceOf[StateNeo4J].sutState - val filterEnd = new Filter("end", ComparisonOperator.EQUALS, targetSutState) - val transitions = session.loadAll(classOf[ActionTransitionEntity], filterStart.and(filterAction).and(filterEnd)) - val first = transitions.stream().findFirst() - val counter = if (first.isPresent) { - first.get().counter = first.get().counter + 1 - session.save(first.get()) - first.get().counter + private[api] override def addTransition(a: ActionIdentifier, to: State): Int = Neo4jSessionFactory.transaction { + /* + TODO #19 Filter for start and end states. + val filterStart = new Filter("start", ComparisonOperator.EQUALS, sutStateIdentifier.hash) + val filterEnd = new Filter("end", ComparisonOperator.EQUALS, targetSutStateIdentifier.hash) + filterStart.and(filterAction).and(filterEnd) + */ + + val filterAction = new Filter("action", ComparisonOperator.EQUALS, a.hash) + val targetSutStateIdentifier = to.asInstanceOf[StateNeo4J].sutStateIdentifier + + import scala.collection.JavaConversions._ + val transitions = session.loadAll(classOf[ActionTransitionEntity], filterAction).toSeq + + val matchingTransitions = transitions.filter(actionTransitionEntity => + actionTransitionEntity.start.id == sutStateIdentifier.hash && actionTransitionEntity.end.id == targetSutStateIdentifier.hash) + if (matchingTransitions.nonEmpty) { + val first: ActionTransitionEntity = matchingTransitions.head + first.counter = first.counter + 1 + session.save(first) + first.counter } else { - val transition = new ActionTransitionEntity(sutState, targetSutState, a) + val sourceState = guiStateMachine.getNodeBySutStateIdentifier(sutStateIdentifier).get + val targetState = guiStateMachine.getNodeBySutStateIdentifier(targetSutStateIdentifier).get + val transition = new ActionTransitionEntity(sourceState, targetState, a.hash) session.save(transition) 1 } - counter } } diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateConverter.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateConverter.scala deleted file mode 100644 index 21bb175..0000000 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateConverter.scala +++ /dev/null @@ -1,13 +0,0 @@ -package de.retest.guistatemachine.api.neo4j -import java.io.ByteArrayInputStream -import java.nio.charset.StandardCharsets - -import de.retest.recheck.XmlTransformerUtil -import de.retest.recheck.ui.descriptors.SutState -import org.neo4j.ogm.typeconversion.AttributeConverter - -class SutStateConverter extends AttributeConverter[SutState, String] { - def toGraphProperty(value: SutState): String = XmlTransformerUtil.getXmlTransformer.toXML(value) - def toEntityAttribute(value: String): SutState = - XmlTransformerUtil.getXmlTransformer.fromXML[SutState](new ByteArrayInputStream(value.getBytes(StandardCharsets.UTF_8))) -} diff --git a/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateEntity.scala b/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateEntity.scala index fbe6d6f..cc5f8c2 100644 --- a/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateEntity.scala +++ b/src/main/scala/de/retest/guistatemachine/api/neo4j/SutStateEntity.scala @@ -1,15 +1,19 @@ package de.retest.guistatemachine.api.neo4j -import de.retest.recheck.ui.descriptors.SutState -import org.neo4j.ogm.annotation._ -import org.neo4j.ogm.annotation.typeconversion.Convert +import de.retest.guistatemachine.api.SutStateIdentifier +import org.neo4j.ogm.annotation.{Relationship, _} + +import scala.collection.mutable @NodeEntity -class SutStateEntity(state: SutState) extends Entity { +class SutStateEntity( + @Id + //@Index(unique = true) + val id: java.lang.String) { - def this() = this(null) + def this(sutStateIdentifier: SutStateIdentifier) = this(sutStateIdentifier.hash) + def this() = this("") - @Index(unique = true) - @Convert(classOf[SutStateConverter]) - val sutState: SutState = state + @Relationship(`type` = "ACTIONS", direction = Relationship.INCOMING) val incomingActionTransitions = mutable.HashSet[ActionTransitionEntity]() + @Relationship(`type` = "ACTIONS", direction = Relationship.OUTGOING) val outgoingActionTransitions = mutable.HashSet[ActionTransitionEntity]() } diff --git a/src/test/scala/de/retest/guistatemachine/api/AbstractApiSpec.scala b/src/test/scala/de/retest/guistatemachine/api/AbstractApiSpec.scala index 1da2772..ff3f227 100644 --- a/src/test/scala/de/retest/guistatemachine/api/AbstractApiSpec.scala +++ b/src/test/scala/de/retest/guistatemachine/api/AbstractApiSpec.scala @@ -37,7 +37,7 @@ abstract trait AbstractApiSpec extends WordSpec with Matchers { "My Window" ) if (numberOfContainedComponents > 0) { - r.addChildren(scala.collection.JavaConverters.seqAsJavaList[Element](0 to numberOfContainedComponents map { _ => + r.addChildren(scala.collection.JavaConversions.seqAsJavaList[Element](0 to numberOfContainedComponents map { _ => getRootElement("x", 0) })) } diff --git a/src/test/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachineJavaObjectStreamSerializerSpec.scala b/src/test/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachineJavaObjectStreamSerializerSpec.scala index 8cd5f31..d9c5f1e 100644 --- a/src/test/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachineJavaObjectStreamSerializerSpec.scala +++ b/src/test/scala/de/retest/guistatemachine/api/impl/serialization/GuiStateMachineJavaObjectStreamSerializerSpec.scala @@ -26,8 +26,6 @@ class GuiStateMachineJavaObjectStreamSerializerSpec extends AbstractApiSpec with val rootElementC = getRootElement("c", 0) val action0 = new NavigateToAction("http://google.com") val action0Identifier = new ActionIdentifier(action0) - val action1 = new NavigateToAction("http://wikipedia.org") - val action1Identifier = new ActionIdentifier(action1) val initialSutState = createSutState(rootElementA, rootElementB, rootElementC) val initialSutStateIdentifier = new SutStateIdentifier(initialSutState) diff --git a/src/test/scala/de/retest/guistatemachine/api/neo4j/ActionConverterSpec.scala b/src/test/scala/de/retest/guistatemachine/api/neo4j/ActionConverterSpec.scala deleted file mode 100644 index c0d8e0b..0000000 --- a/src/test/scala/de/retest/guistatemachine/api/neo4j/ActionConverterSpec.scala +++ /dev/null @@ -1,109 +0,0 @@ -package de.retest.guistatemachine.api.neo4j - -import java.util - -import de.retest.guistatemachine.api.AbstractApiSpec -import de.retest.surili.commons.actions._ -import org.scalatest.BeforeAndAfterEach - -class ActionConverterSpec extends AbstractApiSpec with BeforeAndAfterEach { - private val rootElement = getRootElement("a", 0) - private val sutState = createSutState(rootElement) - private val cut = new ActionConverter(Some(sutState)) - - "ActionConverter" should { - - "convert ChangeValueOfAction" in { - val list = util.Arrays.asList("foo", "bar", "waa") - val cs = list.toArray(new Array[CharSequence](list.size)) - val action = new ChangeValueOfAction(rootElement, cs) - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |ChangeValueOfActionretestIdfoobarwaa - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert ClickOnAction" in { - val action = new ClickOnAction(rootElement) - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |ClickOnActionretestId - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert NavigateToAction" in { - val action = new NavigateToAction("http://google.com") - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |NavigateToActionhttp://google.com - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert NavigateBackAction" in { - val action = new NavigateBackAction() - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |NavigateBackAction - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert NavigateForwardAction" in { - val action = new NavigateForwardAction() - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |NavigateForwardAction - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert NavigateRefreshAction" in { - val action = new NavigateRefreshAction() - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |NavigateRefreshAction - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - - "convert SwitchToWindowAction" in { - val action = new SwitchToWindowAction("test") - - val result = cut.toGraphProperty(action) - result shouldEqual - """ - |SwitchToWindowActiontest - |""".stripMargin - - val loadedAction = cut.toEntityAttribute(result) - loadedAction shouldEqual action - } - } -} diff --git a/src/test/scala/de/retest/guistatemachine/api/neo4j/SutStateConverterSpec.scala b/src/test/scala/de/retest/guistatemachine/api/neo4j/SutStateConverterSpec.scala deleted file mode 100644 index 6f3bd68..0000000 --- a/src/test/scala/de/retest/guistatemachine/api/neo4j/SutStateConverterSpec.scala +++ /dev/null @@ -1,69 +0,0 @@ -package de.retest.guistatemachine.api.neo4j - -import de.retest.guistatemachine.api.AbstractApiSpec -import org.scalatest.BeforeAndAfterEach - -class SutStateConverterSpec extends AbstractApiSpec with BeforeAndAfterEach { - - "SutStateConverter" should { - "save and load SutState " in { - val cut = new SutStateConverter - val rootElementA = getRootElement("a", 0) - val rootElementB = getRootElement("b", 0) - val rootElementC = getRootElement("c", 0) - val initialSutState = createSutState(rootElementA, rootElementB, rootElementC) - - val result = cut.toGraphProperty(initialSutState) - result shouldEqual - """ - | - | - | - | - | a - | a - | a - | - | - | - | - | prefix_039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81 - | PNG - | - | - | - | - | - | b - | b - | b - | - | - | - | - | prefix_039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81 - | PNG - | - | - | - | - | - | c - | c - | c - | - | - | - | - | prefix_039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81 - | PNG - | - | - | - |""".stripMargin - - val loadedSutState = cut.toEntityAttribute(result) - loadedSutState shouldEqual initialSutState - } - } -}