make scripts and interactive mode run again

Author: reinierl

cmd/src/main/scala/chargepoint/docile/test/InteractiveOcppTest.scala

@@ -125,15 +125,15 @@ object InteractiveOcppTest {
         val ops: Ocpp1XTest.V1XOps = new Ocpp1XTest.V1XOps
                 with expectations.Ops[VersionFamily.V1X.type, CentralSystemReq, CentralSystemRes, CentralSystemReqRes, ChargePointReq, ChargePointRes, ChargePointReqRes]
                 with shortsend.OpsV1X {
-          def connectionData = connDat
+          def connection = connDat
 
           implicit val csmsMessageTypes = VersionFamily.V1XCentralSystemMessages
           implicit val csMessageTypes = VersionFamily.V1XChargePointMessages
           implicit val executionContext = global
         }
 
         val promptCommands: InteractiveOcpp1XTest.V1XPromptCommands = new InteractiveOcpp1XTest.V1XPromptCommands {
-          def connectionData = connDat
+          def connection = connDat
         }
       }.asInstanceOf[OcppTest[vfam.type]]
 
@@ -149,15 +149,15 @@ object InteractiveOcppTest {
 
         val ops: Ocpp20Test.V20Ops = new Ocpp20Test.V20Ops
                 with expectations.Ops[VersionFamily.V20.type, CsmsRequest, CsmsResponse, CsmsReqRes, CsRequest, CsResponse, CsReqRes] {
-          def connectionData = connDat
+          def connection = connDat
 
           implicit val csmsMessageTypes = VersionFamily.V20CsmsMessages
           implicit val csMessageTypes = VersionFamily.V20CsMessages
           implicit val executionContext = global
         }
 
         val promptCommands: InteractiveOcpp20Test.V20PromptCommands = new InteractiveOcpp20Test.V20PromptCommands {
-          def connectionData = connDat
+          def connection = connDat
         }
       }.asInstanceOf[OcppTest[vfam.type]]
   }
@@ -173,12 +173,12 @@ object InteractiveOcppTest {
     InReqRes[_ <: InReq, _ <: OutRes] <: ReqRes[_, _]
   ] {
 
-    protected def connectionData: DocileConnection[VFam, VersionBound, OutReq, InRes, OutReqRes, InReq, OutRes, InReqRes]
+    protected def connection: DocileConnection[VFam, VersionBound, OutReq, InRes, OutReqRes, InReq, OutRes, InReqRes]
 
     def q: Unit =
-      connectionData.receivedMsgManager.currentQueueContents foreach println
+      connection.receivedMsgManager.currentQueueContents foreach println
 
     def whoami: Unit =
-      println(connectionData.chargePointIdentity)
+      println(connection.chargePointIdentity)
   }
 }

core/src/main/scala/chargepoint/docile/dsl/CoreOps.scala

@@ -44,7 +44,7 @@ trait CoreOps[
   val logger = Logger(LoggerFactory.getLogger("script"))
   def say(m: String): Unit = logger.info(m)
 
-  protected def connectionData: DocileConnection[VFam, _, OutReq, InRes, OutReqRes, InReq, OutRes, InReqRes]
+  protected def connection: DocileConnection[VFam, _, OutReq, InRes, OutReqRes, InReq, OutRes, InReqRes]
 
   /**
    * Send an OCPP request to the Central System under test.
@@ -59,20 +59,20 @@ trait CoreOps[
    * @tparam Q
    */
   def send[Q <: OutReq](req: Q)(implicit reqRes: OutReqRes[Q, _ <: InRes]): Unit =
-    connectionData.ocppClient match {
+    connection.ocppClient match {
       case None =>
         throw ExpectationFailed("Trying to send an OCPP message while not connected")
       case Some (client) =>
         outgoingLogger.info(s"$req")
         client.send(req)(reqRes) onComplete {
           case Success(res) =>
             incomingLogger.info(s"$res")
-            connectionData.receivedMsgManager.enqueue(
+            connection.receivedMsgManager.enqueue(
               IncomingMessage(res)
             )
           case Failure(OcppException(ocppError)) =>
             incomingLogger.info(s"$ocppError")
-            connectionData.receivedMsgManager.enqueue(
+            connection.receivedMsgManager.enqueue(
               IncomingMessage(ocppError)
             )
           case Failure(e) =>
@@ -83,17 +83,17 @@ trait CoreOps[
 
   // WIP an operation to add a default handler for a certain subset of incoming messages
   def handlingIncomingMessages[T](proc: IncomingMessageProcessor[_])(f: => T): T = {
-    connectionData.pushIncomingMessageHandler(proc)
+    connection.pushIncomingMessageHandler(proc)
     val result = f
-    connectionData.popIncomingMessageHandler()
+    connection.popIncomingMessageHandler()
 
     result
   }
 
   def awaitIncoming(num: Int)(implicit awaitTimeout: AwaitTimeout): Seq[IncomingMessage] = {
 
     val timeout = awaitTimeout.toDuration
-    def getMsgs = connectionData.receivedMsgManager.dequeue(num)
+    def getMsgs = connection.receivedMsgManager.dequeue(num)
 
     Try(Await.result(getMsgs, timeout)) match {
       case Success(msgs)                => msgs
@@ -108,7 +108,7 @@ trait CoreOps[
    * This can be used in interactive mode to get out of a situation where you've received a bunch of messages that you
    * don't really care about, and you want to get on with things.
    */
-  def flushQ(): Unit = connectionData.receivedMsgManager.flush()
+  def flushQ(): Unit = connection.receivedMsgManager.flush()
 
   def fail(message: String): Nothing = throw ExpectationFailed(message)
 

core/src/main/scala/chargepoint/docile/dsl/OcppTest.scala

@@ -236,6 +236,8 @@ trait DocileConnection[
       connectionLogger.info(s"Gracefully disconnected from endpoint $endpoint")
       ocppClient = None
     }(executionContext)
+
+    ocppClient = Some(connection)
   }
 
   /** Template method to be implemented by version-specific extending classes to establish a connection for that

core/src/main/scala/chargepoint/docile/dsl/expectations/Ops.scala

@@ -21,6 +21,7 @@ trait Ops[
 ] {
   self: CoreOps[VFam, OutReq, InRes, OutReqRes, InReq, OutRes, InReqRes] =>
 
+  // TODO document why we need this subset of IncomingMessageProcessor
   sealed trait IncomingRequestProcessor[+T] extends IncomingMessageProcessor[T]
 
   def expectIncoming[T](proc: IncomingMessageProcessor[T])(implicit awaitTimeout: AwaitTimeout): T = {
@@ -129,13 +130,13 @@ trait Ops[
     error restrictedBy { case e@OcppError(`code`, _) => e }
 
 
-  def getConfigurationReq = requestMatching { case r: GetConfigurationReq => r }
+  def getConfigurationReq: IncomingRequestProcessor[GetConfigurationReq] = requestMatching { case r: GetConfigurationReq => r }
   def changeConfigurationReq = requestMatching { case r: ChangeConfigurationReq => r }
   def getDiagnosticsReq = requestMatching { case r: GetDiagnosticsReq => r }
   def changeAvailabilityReq = requestMatching { case r: ChangeAvailabilityReq => r }
-  def getLocalListVersionReq = requestMatching { case r if r == GetLocalListVersionReq => r }
+  def getLocalListVersionReq = requestMatching { case r: GetLocalListVersionReq.type => r }
   def sendLocalListReq = requestMatching { case r: SendLocalListReq => r }
-  def clearCacheReq = requestMatching { case r if r == ClearCacheReq => r }
+  def clearCacheReq: IncomingRequestProcessor[ClearCacheReq.type] = requestMatching { case r: ClearCacheReq.type => r }
   def resetReq = requestMatching { case r: ResetReq => r }
   def updateFirmwareReq = requestMatching { case r: UpdateFirmwareReq => r }
   def remoteStartTransactionReq = requestMatching { case r: RemoteStartTransactionReq => r }

core/src/main/scala/chargepoint/docile/dsl/shortsend/OpsV1X.scala

@@ -40,8 +40,8 @@ trait OpsV1X {
   def bootNotification(
     chargePointVendor: String = "The New Motion BV",
     chargePointModel: String = "Test Basic",
-    chargePointSerialNumber: Option[String] = Some(connectionData.chargePointIdentity),
-    chargeBoxSerialNumber: Option[String] = Some(connectionData.chargePointIdentity),
+    chargePointSerialNumber: Option[String] = Some(connection.chargePointIdentity),
+    chargeBoxSerialNumber: Option[String] = Some(connection.chargePointIdentity),
     firmwareVersion: Option[String] = Some("1.0.0"),
     iccid: Option[String] = None,
     imsi: Option[String] = None,

core/src/main/scala/chargepoint/docile/dsl/shortsend/OpsV20.scala

@@ -43,7 +43,7 @@ trait OpsV20 {
 
   def bootNotification(
     chargingStation: ChargingStation = ChargingStation(
-      serialNumber = Some(connectionData.chargePointIdentity),
+      serialNumber = Some(connection.chargePointIdentity),
       model = "Docile",
       vendorName = "The New Motion BV",
       firmwareVersion = Some("1.0.0"),

core/src/test/scala/chargepoint/docile/dsl/expectations/OpsSpec.scala

@@ -23,9 +23,7 @@ class OpsSpec extends Specification {
       mock send GetConfigurationReq(keys = List())
       mock send ClearCacheReq
 
-      val result: Seq[ChargePointReq] =
-
-      expectAllIgnoringUnmatched(
+      val result: Seq[ChargePointReq] = expectAllIgnoringUnmatched(
         clearCacheReq respondingWith ClearCacheRes(accepted = true)
       )
 
@@ -80,21 +78,13 @@ class OpsSpec extends Specification {
       ](err))
     }
 
-    val ops: Ops[
-      V1X.type,
-      CentralSystemReq,
-      CentralSystemRes,
-      CentralSystemReqRes,
-      ChargePointReq,
-      ChargePointRes,
-      ChargePointReqRes
-    ] = new Ops[V1X.type, CentralSystemReq, CentralSystemRes, CentralSystemReqRes, ChargePointReq, ChargePointRes, ChargePointReqRes]
+    val ops = new Ops[V1X.type, CentralSystemReq, CentralSystemRes, CentralSystemReqRes, ChargePointReq, ChargePointRes, ChargePointReqRes]
             with CoreOps[V1X.type, CentralSystemReq, CentralSystemRes, CentralSystemReqRes, ChargePointReq, ChargePointRes, ChargePointReqRes] {
       implicit val csMessageTypes = V1XChargePointMessages
       implicit val csmsMessageTypes = V1XCentralSystemMessages
       implicit val executionContext = global
 
-      override protected def connectionData: DocileConnection[
+      override protected def connection: DocileConnection[
         V1X.type,
         Version1X,
         CentralSystemReq,

core/src/test/scala/chargepoint/docile/dsl/ocpp20transactions/OpsSpec.scala

@@ -58,7 +58,7 @@ class OpsSpec extends Specification {
     CsResponse,
     CsReqRes
     ] with Ops {
-    protected lazy val connectionData = sys.error("This test should not do anything with the OCPP connection")
+    protected lazy val connection = sys.error("This test should not do anything with the OCPP connection")
     val csmsMessageTypes = V20CsmsMessages
     val csMessageTypes = V20CsMessages
     implicit val executionContext = ExecutionContext.global