Skip to content
This repository has been archived by the owner on Apr 13, 2022. It is now read-only.

Use TestProbe rather than self reference in NodeViewHolderSpec #233

Merged
merged 1 commit into from
Apr 24, 2018
Merged

Use TestProbe rather than self reference in NodeViewHolderSpec #233

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
130 changes: 70 additions & 60 deletions testkit/src/main/scala/scorex/testkit/properties/NodeViewHolderTests.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,153 +58,162 @@ MPool <: MemoryPool[TX, MPool]]

property("NodeViewHolder syntactically valid modifier subscription") { withFixture { ctx =>
import ctx._
val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head }
val mod = receiveOne(5 seconds).asInstanceOf[PM]
node ! LocallyGeneratedModifier(mod)
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head })
val mod = p.expectMsgClass(classOf[PersistentNodeViewModifier])
p.send(node, LocallyGeneratedModifier(mod))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
}}

property("NodeViewHolder: syntactically failed modifier subscription") { withFixture { ctx =>
import ctx._
val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallyFailedModification[PM]])
val invalid = syntacticallyInvalidModifier(h)
node ! LocallyGeneratedModifier(invalid)
p.send(node, LocallyGeneratedModifier(invalid))
eventListener.expectMsgType[SyntacticallyFailedModification[PM]]
}}

property("NodeViewHolder: semantically valid modifier subscription") { withFixture { ctx =>
import ctx._
val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SemanticallySuccessfulModifier[PM]])
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head }
val mod = receiveOne(5 seconds).asInstanceOf[PM]
node ! LocallyGeneratedModifier(mod)
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head })
val mod = p.expectMsgClass(classOf[PersistentNodeViewModifier])
p.send(node, LocallyGeneratedModifier(mod))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
eventListener.expectMsgType[SemanticallySuccessfulModifier[PM]]
}}

property("NodeViewHolder: semantically failed modifier subscription") { withFixture { ctx =>
import ctx._

val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SemanticallyFailedModification[PM]])
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => semanticallyInvalidModifier(v.state) }
val invalid = receiveOne(5 seconds).asInstanceOf[PM]
node ! LocallyGeneratedModifier(invalid)
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => semanticallyInvalidModifier(v.state) })
val invalid = p.expectMsgClass(classOf[PersistentNodeViewModifier])
p.send(node, LocallyGeneratedModifier(invalid))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
eventListener.expectMsgType[SemanticallyFailedModification[PM]]
}}

property("NodeViewHolder: syntactically/semantically valid modifier subscription") { withFixture { ctx =>
import ctx._

val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SemanticallySuccessfulModifier[PM]])
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head }
val mod = receiveOne(5 seconds).asInstanceOf[PM]
node ! LocallyGeneratedModifier(mod)
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v => totallyValidModifiers(v.history, v.state, 2).head })
val mod = p.expectMsgClass(classOf[PersistentNodeViewModifier])
p.send(node, LocallyGeneratedModifier(mod))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
eventListener.expectMsgType[SemanticallySuccessfulModifier[PM]]
}}

property("NodeViewHolder: check state after creation") { withFixture { ctx =>
import ctx._
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
val p = TestProbe()

p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
v.state.version.sameElements(s.version)
}
expectMsg(true)
})
p.expectMsg(true)
}}

property("NodeViewHolder: check that a valid modifier is applicable") { withFixture { ctx =>
import ctx._
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
val p = TestProbe()

p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
v.history.applicable(mod)
}
expectMsg(true)
})
p.expectMsg(true)
}}

property("NodeViewHolder: check that valid modifiers are applicable") { withFixture { ctx =>
import ctx._
val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallyFailedModification[PM]])
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
totallyValidModifiers(v.history, v.state, 10) //todo: fix magic number
}
val mods = receiveOne(5 seconds).asInstanceOf[Seq[PM]]
})
val mods = p.expectMsgClass(classOf[Seq[PersistentNodeViewModifier]])

mods.foreach { mod =>
node ! LocallyGeneratedModifier(mod)
p.send(node, LocallyGeneratedModifier(mod))
}

(1 to mods.size).foreach(_ => eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]])
}}

property("NodeViewHolder: apply locally generated mod") { withFixture { ctx =>
import ctx._
val p = TestProbe()

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallyFailedModification[PM]])

val invalid = syntacticallyInvalidModifier(h)

node ! LocallyGeneratedModifier(invalid)
p.send(node, LocallyGeneratedModifier(invalid))

eventListener.expectMsgType[SyntacticallyFailedModification[PM]]

node ! LocallyGeneratedModifier(mod)
p.send(node, LocallyGeneratedModifier(mod))

eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
v.state.version.sameElements(s.version) && v.history.contains(mod.id)
}
})

expectMsg(true)
p.expectMsg(true)
}}

property("NodeViewHolder: simple forking") { withFixture { ctx =>
import ctx._
val p = TestProbe()

val waitDuration = 5.seconds

system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallySuccessfulModifier[PM]])
system.eventStream.subscribe(eventListener.ref, classOf[SyntacticallyFailedModification[PM]])

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v => totallyValidModifiers(v.history, v.state, 2) }
val initMods = receiveOne(waitDuration).asInstanceOf[Seq[PM]]
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v => totallyValidModifiers(v.history, v.state, 2) })
val initMods = p.expectMsgClass(waitDuration, classOf[Seq[PersistentNodeViewModifier]])
initMods.foreach { mod =>
node ! LocallyGeneratedModifier(mod)
p.send(node, LocallyGeneratedModifier(mod))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
}

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v =>
totallyValidModifiers(v.history, v.state, 2).head
}
val fork1Mod = receiveOne(waitDuration).asInstanceOf[PM]
})
val fork1Mod = p.expectMsgClass(waitDuration, classOf[PersistentNodeViewModifier])

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, PM] { v =>
totallyValidModifiers(v.history, v.state, 2).head
}
val fork2Mod = receiveOne(waitDuration).asInstanceOf[PM]
})
val fork2Mod = p.expectMsgClass(waitDuration, classOf[PersistentNodeViewModifier])

node ! LocallyGeneratedModifier(fork1Mod)
node ! LocallyGeneratedModifier(fork2Mod)
p.send(node, LocallyGeneratedModifier(fork1Mod))
p.send(node, LocallyGeneratedModifier(fork2Mod))
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]
eventListener.expectMsgType[SyntacticallySuccessfulModifier[PM]]

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
v.history.contains(fork1Mod.id) || v.history.contains(fork2Mod.id)
}

})

expectMsg(10.seconds, true)
p.expectMsg(10.seconds, true)
}}

/**
Expand All @@ -215,6 +224,7 @@ MPool <: MemoryPool[TX, MPool]]
*/
property("NodeViewHolder: forking - switching") { withFixture { ctx =>
import ctx._
val p = TestProbe()

val opCountBeforeFork = 10
val fork1OpCount = 2
Expand All @@ -223,30 +233,30 @@ MPool <: MemoryPool[TX, MPool]]
val waitDuration = 10.seconds

//some base operations, we don't wanna have fork right from genesis
node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
totallyValidModifiers(v.history, v.state, opCountBeforeFork)
}
val plainMods = receiveOne(waitDuration).asInstanceOf[Seq[PM]]
plainMods.foreach { mod => node ! LocallyGeneratedModifier(mod) }
})
val plainMods = p.expectMsgClass(waitDuration, classOf[Seq[PersistentNodeViewModifier]])
plainMods.foreach { mod => p.send(node, LocallyGeneratedModifier(mod)) }

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
val mods = totallyValidModifiers(v.history, v.state, fork1OpCount)
assert(mods.head.parentId.sameElements(v.history.openSurfaceIds().head))
mods
}
val fork1Mods = receiveOne(waitDuration).asInstanceOf[Seq[PM]]
})
val fork1Mods = p.expectMsgClass(waitDuration, classOf[Seq[PersistentNodeViewModifier]])

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Seq[PM]] { v =>
totallyValidModifiers(v.history, v.state, fork2OpCount)
}
val fork2Mods = receiveOne(waitDuration).asInstanceOf[Seq[PM]]
})
val fork2Mods = p.expectMsgClass(waitDuration, classOf[Seq[PersistentNodeViewModifier]])

fork1Mods.foreach { mod => node ! LocallyGeneratedModifier(mod) }
fork2Mods.foreach { mod => node ! LocallyGeneratedModifier(mod) }
fork1Mods.foreach { mod => p.send(node, LocallyGeneratedModifier(mod)) }
fork2Mods.foreach { mod => p.send(node, LocallyGeneratedModifier(mod)) }

node ! GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
p.send(node, GetDataFromCurrentView[HT, ST, Vault[P, TX, PM, _], MPool, Boolean] { v =>
v.history.openSurfaceIds().contains(fork2Mods.last.id)
}
expectMsg(true)
})
p.expectMsg(true)
}}
}