diff --git a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandler.scala b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandler.scala index f70eac475a..880610806e 100644 --- a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandler.scala +++ b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandler.scala @@ -4,9 +4,9 @@ import akka.pattern.AskableActorRef import ch.epfl.pop.json.MessageDataProtocol.{KeyElectionFormat, resultElectionFormat} import ch.epfl.pop.model.network.JsonRpcRequest import ch.epfl.pop.model.network.method.message.data.election.VersionType -import ch.epfl.pop.model.network.method.message.data.election._ -import ch.epfl.pop.model.objects.ElectionChannel._ -import ch.epfl.pop.model.objects._ +import ch.epfl.pop.model.network.method.message.data.election.* +import ch.epfl.pop.model.objects.ElectionChannel.* +import ch.epfl.pop.model.objects.* import ch.epfl.pop.pubsub.graph.{ErrorCodes, GraphMessage, PipelineError} import ch.epfl.pop.storage.DbActor import ch.epfl.pop.storage.DbActor.DbActorReadElectionDataAck @@ -14,31 +14,12 @@ import ch.epfl.pop.storage.DbActor.DbActorReadElectionDataAck import scala.collection.mutable import scala.concurrent.ExecutionContext.Implicits.global import scala.concurrent.{Await, Future} -import scala.util.{Failure, Success} +import scala.util.{Failure, Right, Success} /** ElectionHandler object uses the db instance from the MessageHandler */ object ElectionHandler extends MessageHandler { - final lazy val handlerInstance = new ElectionHandler(super.dbActor) - def handleSetupElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleSetupElection(rpcMessage) - - def handleOpenElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleOpenElection(rpcMessage) - - def handleCastVoteElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleCastVoteElection(rpcMessage) - - def handleResultElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleResultElection(rpcMessage) - - def handleEndElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleEndElection(rpcMessage) - - def handleKeyElection(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleKeyElection(rpcMessage) -} - -class ElectionHandler(dbRef: => AskableActorRef) extends MessageHandler { - - /** Overrides default DbActor with provided parameter - */ - override final val dbActor: AskableActorRef = dbRef private val serverUnexpectedAnswer: String = "The server is doing something unexpected" def handleSetupElection(rpcMessage: JsonRpcRequest): GraphMessage = { diff --git a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandler.scala b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandler.scala index e7c5c7c765..8bafb4ad53 100644 --- a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandler.scala +++ b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandler.scala @@ -16,28 +16,6 @@ import scala.util.{Failure, Success} /** RollCallHandler object uses the db instance from the MessageHandler (i.e PublishSubscribe) */ object RollCallHandler extends MessageHandler { - final lazy val handlerInstance = new RollCallHandler(super.dbActor) - - def handleCreateRollCall(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleCreateRollCall(rpcMessage) - - def handleOpenRollCall(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleOpenRollCall(rpcMessage) - - def handleReopenRollCall(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleReopenRollCall(rpcMessage) - - def handleCloseRollCall(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleCloseRollCall(rpcMessage) -} - -/** Implementation of the RollCallHandler that provides a testable interface - * - * @param dbRef - * reference of the db actor - */ -class RollCallHandler(dbRef: => AskableActorRef) extends MessageHandler { - - /** Overrides default DbActor with provided parameter - */ - override final val dbActor: AskableActorRef = dbRef - private val serverUnexpectedAnswer: String = "The server is doing something unexpected" def handleCreateRollCall(rpcRequest: JsonRpcRequest): GraphMessage = { diff --git a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandler.scala b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandler.scala index f8d3ca4763..e1deba040b 100644 --- a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandler.scala +++ b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandler.scala @@ -15,28 +15,6 @@ import scala.concurrent.{Await, Future} import scala.util.{Failure, Success} object SocialMediaHandler extends MessageHandler { - final lazy val handlerInstance = new SocialMediaHandler(super.dbActor, super.mediator) - - def handleAddChirp(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleAddChirp(rpcMessage) - - def handleDeleteChirp(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleDeleteChirp(rpcMessage) - - def handleNotifyAddChirp(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleNotifyAddChirp(rpcMessage) - - def handleNotifyDeleteChirp(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleNotifyDeleteChirp(rpcMessage) - - def handleAddReaction(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleAddReaction(rpcMessage) - - def handleDeleteReaction(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleDeleteReaction(rpcMessage) -} - -class SocialMediaHandler(dbRef: => AskableActorRef, mediatorRef: => AskableActorRef) extends MessageHandler { - - /** Overrides default DbActor with provided parameter - */ - override final val dbActor: AskableActorRef = dbRef - override final val mediator: AskableActorRef = mediatorRef - private final val unknownAnswerDatabase: String = "Database actor returned an unknown answer" private def generateSocialChannel(laoId: Hash): Channel = Channel(Channel.ROOT_CHANNEL_PREFIX + laoId + Channel.SOCIAL_MEDIA_CHIRPS_PREFIX) diff --git a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandler.scala b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandler.scala index 1635d7c59e..3b592da511 100644 --- a/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandler.scala +++ b/be2-scala/src/main/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandler.scala @@ -15,18 +15,7 @@ import scala.concurrent.ExecutionContext.Implicits.global /** WitnessHandler object uses the db instance from the MessageHandler */ -object WitnessHandler { - final lazy val handlerInstance = new WitnessHandler(DbActor.getInstance) - - def handleWitnessMessage(rpcMessage: JsonRpcRequest): GraphMessage = handlerInstance.handleWitnessMessage(rpcMessage) -} - -class WitnessHandler(dbRef: => AskableActorRef) extends MessageHandler { - - /** Overrides default DbActor with provided parameter - */ - override final val dbActor: AskableActorRef = dbRef - +object WitnessHandler extends MessageHandler { def handleWitnessMessage(rpcMessage: JsonRpcRequest): GraphMessage = { val combined = for { diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandlerTest.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandlerTest.scala index 2124afbaa5..fb013b29ac 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandlerTest.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/ElectionHandlerTest.scala @@ -1,23 +1,27 @@ package ch.epfl.pop.pubsub.graph.handlers +import akka.NotUsed import akka.actor.{Actor, ActorSystem, Props, Status} +import akka.http.scaladsl.model.ws import akka.pattern.{AskableActorRef, ask} +import akka.stream.scaladsl.Flow import akka.testkit.{ImplicitSender, TestKit} import akka.util.Timeout import ch.epfl.pop.model.network.method.message.Message import ch.epfl.pop.model.network.method.message.data.ObjectType -import ch.epfl.pop.model.objects._ +import ch.epfl.pop.model.objects.* +import ch.epfl.pop.pubsub.{MessageRegistry, PublishSubscribe} import ch.epfl.pop.pubsub.graph.PipelineError import ch.epfl.pop.storage.DbActor import org.scalatest.BeforeAndAfterAll -import org.scalatest.funsuite.{AnyFunSuiteLike => FunSuiteLike} +import org.scalatest.funsuite.AnyFunSuiteLike as FunSuiteLike import org.scalatest.matchers.should.Matchers -import util.examples.Election.CastVoteElectionExamples._ -import util.examples.Election.EndElectionExamples._ -import util.examples.Election.OpenElectionExamples._ -import util.examples.Election.SetupElectionExamples._ -import util.examples.Election._ -import util.examples.data._ +import util.examples.Election.CastVoteElectionExamples.* +import util.examples.Election.EndElectionExamples.* +import util.examples.Election.OpenElectionExamples.* +import util.examples.Election.SetupElectionExamples.* +import util.examples.Election.* +import util.examples.data.* import util.examples.LaoDataExample import scala.concurrent.duration.FiniteDuration @@ -214,142 +218,144 @@ class ElectionHandlerTest extends TestKit(ActorSystem("Election-DB-System")) wit system.actorOf(dbActorMock) } + private def injectDb(dbRef: AskableActorRef) = PublishSubscribe.buildGraph(Actor.noSender, dbRef, Actor.noSender, MessageRegistry(), Actor.noSender, Actor.noSender, Actor.noSender, false) + test("SetupElection should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = SetupElectionMessages.setupElection - rc.handleSetupElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleSetupElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("SetupElection should succeed if the election doesn't already exists in database") { val mockedDB = mockDbElectionNotSetUp - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = SetupElectionMessages.setupElection - rc.handleSetupElection(request) should equal(Right(request)) + ElectionHandler.handleSetupElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("SetupElection with secret ballot should succeed if it is stored correctly in the database") { val mockedDB = mockDbWithAck - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = SetupElectionMessages.setupElectionSecretBallot - rc.handleSetupElection(request) should equal(Right(request)) + ElectionHandler.handleSetupElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("SetupElection with secret ballot should fail if the election cannot read in the lao data") { val mockedDB = mockDbElectionSecretBallotReadFailed - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = SetupElectionMessages.setupElectionSecretBallot - rc.handleSetupElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleSetupElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("OpenElection should succeed if the election already exists") { val mockedDB = mockDbWithAck - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = OpenElectionMessages.openElection - rc.handleOpenElection(request) should equal(Right(request)) + ElectionHandler.handleOpenElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("OpenElection should fail if the election does not exist") { val mockedDB = mockDbElectionNotSetUp - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = OpenElectionMessages.openElection - rc.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("OpenElection should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = OpenElectionMessages.openElection - rc.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("CastVoteElection should succeed if the election already exists") { val mockedDB = mockDbWithAck - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = CastVoteElectionMessages.castVoteElection - rc.handleCastVoteElection(request) should equal(Right(request)) + ElectionHandler.handleCastVoteElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("CastVoteElection should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = CastVoteElectionMessages.castVoteElection - rc.handleCastVoteElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleCastVoteElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } /*test("EndElection should succeed if the election already exists") { val mockedDB = mockDbWithAckEndElection - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = EndElectionMessages.endElection - rc.handleEndElection(request) should equal(Right(request)) + ElectionHandler.handleEndElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) }*/ test("EndElection should fail if the election does not exist") { val mockedDB = mockDbElectionNotSetUp - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = EndElectionMessages.endElection - rc.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleOpenElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("EndElection should fail if the database fails storing the message") { val mockedDB = mockDbWithNAckEndElection - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = EndElectionMessages.endElection - rc.handleEndElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleEndElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("KeyElection should succeed if the election already exists") { val mockedDB = mockDbWithAck - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = KeyElectionMessages.keyElection - rc.handleKeyElection(request) should equal(Right(request)) + ElectionHandler.handleKeyElection(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("keyElection should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new ElectionHandler(mockedDB) + injectDb(mockedDB) val request = KeyElectionMessages.keyElection - rc.handleKeyElection(request) shouldBe an[Left[PipelineError, _]] + ElectionHandler.handleKeyElection(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/GetMessagesByIdResponseHandlerSuite.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/GetMessagesByIdResponseHandlerSuite.scala index 453a6eef06..c615b45ab1 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/GetMessagesByIdResponseHandlerSuite.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/GetMessagesByIdResponseHandlerSuite.scala @@ -4,7 +4,7 @@ import akka.NotUsed import akka.actor.{ActorRef, ActorSystem, Props} import akka.pattern.{AskableActorRef, ask} import akka.stream.scaladsl.{Flow, Sink, Source} -import akka.testkit.TestKit +import akka.testkit.{TestKit, TestKitBase} import akka.util.Timeout import ch.epfl.pop.IOHelper.readJsonFromPath import ch.epfl.pop.model.network.JsonRpcResponse @@ -17,13 +17,15 @@ import ch.epfl.pop.storage.{DbActor, InMemoryStorage, SecurityModuleActor} import org.scalatest.BeforeAndAfterAll import org.scalatest.funsuite.AnyFunSuiteLike import org.scalatest.matchers.should.Matchers -import org.scalatest.matchers.should.Matchers._ +import org.scalatest.matchers.should.Matchers.* import scala.concurrent.Await import scala.concurrent.duration.{DurationInt, FiniteDuration} import scala.util.Success -class GetMessagesByIdResponseHandlerSuite extends TestKit(ActorSystem("GetMessagesByIdResponseHandlerSuiteSystem")) with AnyFunSuiteLike with AskPatternConstants with BeforeAndAfterAll { +class GetMessagesByIdResponseHandlerSuite extends TestKitBase with AnyFunSuiteLike with AskPatternConstants with BeforeAndAfterAll { + + implicit val system: ActorSystem = ActorSystem("GetMessagesByIdResponseHandlerSuiteSystem") // Implicit for system actors implicit val timeout: Timeout = Timeout(1.seconds) @@ -35,8 +37,11 @@ class GetMessagesByIdResponseHandlerSuite extends TestKit(ActorSystem("GetMessag val dbActorRef: AskableActorRef = system.actorOf(Props(DbActor(pubSubMediatorRef, messageRegistry, inMemoryStorage)), "DbActor") val securityModuleActorRef: AskableActorRef = system.actorOf(Props(SecurityModuleActor(testSecurityDirectory))) - // Inject dbActor above - PublishSubscribe.buildGraph(pubSubMediatorRef, dbActorRef, securityModuleActorRef, messageRegistry, ActorRef.noSender, ActorRef.noSender, ActorRef.noSender, isServer = false) + override def beforeAll(): Unit = { + // Inject dbActor above + PublishSubscribe.buildGraph(pubSubMediatorRef, dbActorRef, securityModuleActorRef, messageRegistry, ActorRef.noSender, ActorRef.noSender, ActorRef.noSender, isServer = false) + + } // handler we want to test val responseHandler: Flow[GraphMessage, GraphMessage, NotUsed] = ProcessMessagesHandler.getMsgByIdResponseHandler(MessageRegistry()) diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandlerTest.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandlerTest.scala index 95e4a1e469..87104c7c06 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandlerTest.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RollCallHandlerTest.scala @@ -5,10 +5,11 @@ import akka.pattern.{AskableActorRef, ask} import akka.testkit.{ImplicitSender, TestKit} import akka.util.Timeout import ch.epfl.pop.model.objects.DbActorNAckException +import ch.epfl.pop.pubsub.{MessageRegistry, PublishSubscribe} import ch.epfl.pop.pubsub.graph.PipelineError import ch.epfl.pop.storage.DbActor import org.scalatest.BeforeAndAfterAll -import org.scalatest.funsuite.{AnyFunSuiteLike => FunSuiteLike} +import org.scalatest.funsuite.AnyFunSuiteLike as FunSuiteLike import org.scalatest.matchers.should.Matchers import util.examples.data.{CloseRollCallMessages, CreateRollCallMessages, OpenRollCallMessages, ReopenRollCallMessages} @@ -89,75 +90,77 @@ class RollCallHandlerTest extends TestKit(ActorSystem("RollCall-DB-System")) wit system.actorOf(dbActorMock) } + private def injectDb(dbRef: AskableActorRef) = PublishSubscribe.buildGraph(Actor.noSender, dbRef, Actor.noSender, MessageRegistry(), Actor.noSender, Actor.noSender, Actor.noSender, false) + test("CreateRollCall should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = CreateRollCallMessages.createRollCall - rc.handleCreateRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleCreateRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("CreateRollCall should succeed if the rollcall doesn't already exist in the database") { val mockedDB = mockDbRollCallNotCreated - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = CreateRollCallMessages.createRollCall - rc.handleCreateRollCall(request) should matchPattern { case Right(_) => } + RollCallHandler.handleCreateRollCall(request) should matchPattern { case Right(_) => } system.stop(mockedDB.actorRef) } test("CreateRollCall should fail if the rollcall already exists in database") { val mockedDB = mockDbRollCallAlreadyCreated - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = CreateRollCallMessages.createRollCall - rc.handleCreateRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleCreateRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("OpenRollCall should fail if the rollcall does not exist in database") { val mockedDB = mockDbRollCallNotCreated - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = OpenRollCallMessages.openRollCall - rc.handleOpenRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleOpenRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("OpenRollCall should succeed if the rollcall is already created") { val mockedDB = mockDbRollCallAlreadyCreated - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = OpenRollCallMessages.openRollCall - rc.handleOpenRollCall(request) should matchPattern { case Right(_) => } + RollCallHandler.handleOpenRollCall(request) should matchPattern { case Right(_) => } system.stop(mockedDB.actorRef) } test("OpenRollCall should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = OpenRollCallMessages.openRollCall - rc.handleOpenRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleOpenRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("ReopenRollcall should succeed if the rollcall is already created") { val mockedDB = mockDbRollCallAlreadyCreated - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = ReopenRollCallMessages.reopenRollCall - rc.handleReopenRollCall(request) should matchPattern { case Right(_) => } + RollCallHandler.handleReopenRollCall(request) should matchPattern { case Right(_) => } system.stop(mockedDB.actorRef) } test("ReopenRollcall should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = ReopenRollCallMessages.reopenRollCall - rc.handleReopenRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleReopenRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("CloseRollcall should fail if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new RollCallHandler(mockedDB) + injectDb(mockedDB) val request = CloseRollCallMessages.closeRollCall - rc.handleCloseRollCall(request) shouldBe an[Left[PipelineError, _]] + RollCallHandler.handleCloseRollCall(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RumorHandlerSuite.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RumorHandlerSuite.scala index 9e91b1e3d8..ace3ff3cec 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RumorHandlerSuite.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/RumorHandlerSuite.scala @@ -4,7 +4,7 @@ import akka.NotUsed import akka.actor.Status.Failure import akka.actor.{ActorRef, ActorSystem, Props} import akka.pattern.AskableActorRef -import akka.testkit.{TestKit, TestProbe} +import akka.testkit.{TestKit, TestKitBase, TestProbe} import ch.epfl.pop.pubsub.{AskPatternConstants, MessageRegistry, PubSubMediator, PublishSubscribe} import ch.epfl.pop.storage.{DbActor, InMemoryStorage, SecurityModuleActor} import akka.pattern.ask @@ -27,8 +27,9 @@ import org.scalatest.matchers.should.Matchers.{a, equal, should, shouldBe} import scala.concurrent.Await import scala.concurrent.duration.FiniteDuration -class RumorHandlerSuite extends TestKit(ActorSystem("RumorActorSuiteActorSystem")) with AnyFunSuiteLike with AskPatternConstants with BeforeAndAfterAll with BeforeAndAfterEach { +class RumorHandlerSuite extends TestKitBase with AnyFunSuiteLike with AskPatternConstants with BeforeAndAfterAll with BeforeAndAfterEach { + implicit val system: ActorSystem = ActorSystem("RumorActorSuiteActorSystem") val MAX_TIME: FiniteDuration = duration.mul(2) private val inMemoryStorage: InMemoryStorage = InMemoryStorage() @@ -39,8 +40,12 @@ class RumorHandlerSuite extends TestKit(ActorSystem("RumorActorSuiteActorSystem" private val monitorRef: ActorRef = system.actorOf(Monitor.props(dbActorRef), "monitorRumor") private var connectionMediatorRef: AskableActorRef = system.actorOf(ConnectionMediator.props(monitorRef, pubSubMediatorRef, dbActorRef, securityModuleActorRef, messageRegistry), "connMediatorRumor") private val rumorHandler: Flow[GraphMessage, GraphMessage, NotUsed] = ParamsHandler.rumorHandler(dbActorRef, messageRegistry) - // Inject dbActor above - PublishSubscribe.buildGraph(pubSubMediatorRef, dbActorRef, securityModuleActorRef, messageRegistry, ActorRef.noSender, ActorRef.noSender, ActorRef.noSender, isServer = false) + + override def beforeAll(): Unit = { + // Inject dbActor above + PublishSubscribe.buildGraph(pubSubMediatorRef, dbActorRef, securityModuleActorRef, messageRegistry, ActorRef.noSender, ActorRef.noSender, ActorRef.noSender, isServer = false) + + } val pathCorrectRumor: String = "src/test/scala/util/examples/json/rumor/rumor_correct_msg.json" @@ -125,7 +130,7 @@ class RumorHandlerSuite extends TestKit(ActorSystem("RumorActorSuiteActorSystem" } // https://github.com/dedis/popstellar/issues/1870 - /*test("rumor handler should process messages received in a rumor") { + test("rumor handler should process messages received in a rumor") { val dbRef = PublishSubscribe.getDbActorRef val output = Source.single(Right(rumorRequest)).via(rumorHandler).runWith(Sink.head) @@ -144,6 +149,6 @@ class RumorHandlerSuite extends TestKit(ActorSystem("RumorActorSuiteActorSystem" val messagesInRumor = rumor.messages.values.foldLeft(Set.empty: Set[Message])((acc, set) => acc ++ set) messagesInRumor.diff(messagesInDb) should equal(Set.empty) - }*/ + } } diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandlerSuite.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandlerSuite.scala index 3268a2e646..4af9870c3a 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandlerSuite.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/SocialMediaHandlerSuite.scala @@ -1,15 +1,15 @@ package ch.epfl.pop.pubsub.graph.handlers -import akka.actor.{Actor, ActorSystem, Props, Status} +import akka.actor.{Actor, ActorRef, ActorSystem, Props, Status} import akka.pattern.{AskableActorRef, ask} import akka.testkit.{ImplicitSender, TestKit} import akka.util.Timeout import ch.epfl.pop.model.objects.DbActorNAckException -import ch.epfl.pop.pubsub.PubSubMediator +import ch.epfl.pop.pubsub.{MessageRegistry, PubSubMediator, PublishSubscribe} import ch.epfl.pop.pubsub.graph.PipelineError import ch.epfl.pop.storage.DbActor import org.scalatest.BeforeAndAfterAll -import org.scalatest.funsuite.{AnyFunSuiteLike => FunSuiteLike} +import org.scalatest.funsuite.AnyFunSuiteLike as FunSuiteLike import org.scalatest.matchers.should.Matchers import util.examples.LaoDataExample import util.examples.data.{AddChirpMessages, AddReactionMessages, DeleteChirpMessages, DeleteReactionMessages} @@ -20,14 +20,14 @@ class SocialMediaHandlerSuite extends TestKit(ActorSystem("SocialMedia-DB-System // Implicits for system actors implicit val duration: FiniteDuration = FiniteDuration(5, "seconds") implicit val timeout: Timeout = Timeout(duration) - private val mockMed: AskableActorRef = mockMediator + private val mockMed: ActorRef = mockMediator override def afterAll(): Unit = { // Stops the testKit TestKit.shutdownActorSystem(system) } - def mockMediator: AskableActorRef = { + def mockMediator: ActorRef = { val mediatorMock = Props(new Actor() { override def receive: Receive = { case PubSubMediator.Propagate(_, _) => @@ -142,133 +142,135 @@ class SocialMediaHandlerSuite extends TestKit(ActorSystem("SocialMedia-DB-System system.actorOf(dbActorMock) } + private def injectDb(dbRef: AskableActorRef) = PublishSubscribe.buildGraph(mockMed, dbRef, Actor.noSender, MessageRegistry(), Actor.noSender, Actor.noSender, Actor.noSender, false) + test("AddReaction fails if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddReactionMessages.addReaction - rc.handleAddReaction(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleAddReaction(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("AddReaction succeeds if the database succeeds storing the message") { val mockedDB = mockDbWithAck - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddReactionMessages.addReaction - rc.handleAddReaction(request) should equal(Right(request)) + SocialMediaHandler.handleAddReaction(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("DeleteReaction fails if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteReactionMessages.deleteReaction - rc.handleDeleteReaction(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleDeleteReaction(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("DeleteReaction succeeds if the database succeeds storing the message") { val mockedDB = mockDbWithAck - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteReactionMessages.deleteReaction - rc.handleDeleteReaction(request) should equal(Right(request)) + SocialMediaHandler.handleDeleteReaction(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("AddChirp fails if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddChirpMessages.addChirp - rc.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("AddChirp fails if the database provides 'None' laoId") { val mockedDB = mockDbWithAckButEmptyAckLaoData - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddChirpMessages.addChirp - rc.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("AddChirp fails if the database fails to provide laoId") { val mockedDB = mockDbWithAckButNAckLaoData - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddChirpMessages.addChirp - rc.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleAddChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("AddChirp succeeds if the database succeeds storing the message and managing the notify") { val mockedDB = mockDbWithAck - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = AddChirpMessages.addChirp - rc.handleAddChirp(request) should equal(Right(request)) + SocialMediaHandler.handleAddChirp(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("DeleteChirp fails if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteChirpMessages.deleteChirp - rc.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("DeleteChirp succeeds if the database succeeds storing the message and managing the notify") { val mockedDB = mockDbWithAck - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteChirpMessages.deleteChirp - rc.handleDeleteChirp(request) should equal(Right(request)) + SocialMediaHandler.handleDeleteChirp(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("DeleteChirp fails if the database succeeds storing the message but fails the notify") { val mockedDB = mockDbWithAckAndNotifyNAck - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteChirpMessages.deleteChirp - rc.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("DeleteChirp fails if the database provides 'None' laoId") { val mockedDB = mockDbWithAckButEmptyAckLaoData - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteChirpMessages.deleteChirp - rc.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("DeleteChirp fails if the database fails to provide laoId") { val mockedDB = mockDbWithAckButNAckLaoData - val rc = new SocialMediaHandler(mockedDB, mockMed) + injectDb(mockedDB) val request = DeleteChirpMessages.deleteChirp - rc.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] + SocialMediaHandler.handleDeleteChirp(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } diff --git a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandlerTest.scala b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandlerTest.scala index 039bb5dcc3..8d58acf28f 100644 --- a/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandlerTest.scala +++ b/be2-scala/src/test/scala/ch/epfl/pop/pubsub/graph/handlers/WitnessHandlerTest.scala @@ -6,11 +6,12 @@ import akka.testkit.{ImplicitSender, TestKit} import akka.util.Timeout import ch.epfl.pop.model.network.method.message.Message import ch.epfl.pop.model.objects.{Base64Data, DbActorNAckException, Hash, Signature, WitnessSignaturePair} +import ch.epfl.pop.pubsub.{MessageRegistry, PublishSubscribe} import ch.epfl.pop.pubsub.graph.PipelineError import ch.epfl.pop.storage.DbActor import ch.epfl.pop.storage.DbActor.DbActorAddWitnessSignatureAck import org.scalatest.BeforeAndAfterAll -import org.scalatest.funsuite.{AnyFunSuiteLike => FunSuiteLike} +import org.scalatest.funsuite.AnyFunSuiteLike as FunSuiteLike import org.scalatest.matchers.should.Matchers import util.examples.data.WitnessMessages import util.examples.Lao.CreateLaoExamples.{SENDER, createLao} @@ -93,32 +94,34 @@ class WitnessHandlerTest extends TestKit(ActorSystem("Witness-DB-System")) with system.actorOf(dbActorMock) } + private def injectDb(dbRef: AskableActorRef) = PublishSubscribe.buildGraph(Actor.noSender, dbRef, Actor.noSender, MessageRegistry(), Actor.noSender, Actor.noSender, Actor.noSender, false) + test("WitnessMessage fails if the database fails storing the message") { val mockedDB = mockDbWithNack - val rc = new WitnessHandler(mockedDB) + injectDb(mockedDB) val request = WitnessMessages.witnessMessage - rc.handleWitnessMessage(request) shouldBe an[Left[PipelineError, _]] + WitnessHandler.handleWitnessMessage(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) } test("WitnessMessage succeeds if the database succeeds storing the message") { val mockedDB = mockDbWithAck - val rc = new WitnessHandler(mockedDB) + injectDb(mockedDB) val request = WitnessMessages.witnessMessage - rc.handleWitnessMessage(request) should equal(Right(request)) + WitnessHandler.handleWitnessMessage(request) should equal(Right(request)) system.stop(mockedDB.actorRef) } test("WitnessMessage fails if the database fails adding a witness signature") { val mockedDB = mockDbWithNackAddWitnessSignature - val rc = new WitnessHandler(mockedDB) + injectDb(mockedDB) val request = WitnessMessages.witnessMessage - rc.handleWitnessMessage(request) shouldBe an[Left[PipelineError, _]] + WitnessHandler.handleWitnessMessage(request) shouldBe an[Left[PipelineError, _]] system.stop(mockedDB.actorRef) }