Redesigning API and ServerTests for instances/{id}/matchingResult and formatting codes

Author: 24santoshr

src/main/scala/de/upb/cs/swt/delphi/instanceregistry/connection/Server.scala

@@ -11,16 +11,13 @@ import de.upb.cs.swt.delphi.instanceregistry.authorization.AccessTokenEnums.User
 import de.upb.cs.swt.delphi.instanceregistry.authorization.{AccessToken, AuthProvider}
 import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.InstanceEnums.ComponentType
 import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.{EventJsonSupport, Instance, InstanceJsonSupport, InstanceLinkJsonSupport}
+import de.upb.cs.swt.delphi.instanceregistry.requestLimiter.{IpLogActor, RequestLimitScheduler}
 import de.upb.cs.swt.delphi.instanceregistry.{AppLogging, Registry, RequestHandler}
 import spray.json.JsonParser.ParsingException
 import spray.json._
 
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.ExecutionContext
 import scala.util.{Failure, Success}
-import de.upb.cs.swt.delphi.instanceregistry.requestLimiter.{IpLogActor, RequestLimitScheduler}
-import sun.font.Decoration.Label
-
-import scala.collection.immutable.Range
 
 /**
   * Web server configuration for Instance Registry API.
@@ -75,7 +72,9 @@ class Server(handler: RequestHandler) extends HttpApp
               matchingInstance(Id)
             } ~
             path("matchingResult") {
-              entity(as[JsValue]) { json => matchInstance(Id, json.asJsObject.fields("MatchingSuccessful").asInstanceOf[Boolean], json.asJsObject.fields("SenderId").asInstanceOf[Long]) }
+              entity(as[JsValue]) {
+                json => matchInstance(Id, json.asJsObject.fields("MatchingSuccessful").toString(), json.asJsObject.fields("SenderId").toString())
+              }
             } ~
             path("eventList") {
               eventList(Id)
@@ -341,10 +340,13 @@ class Server(handler: RequestHandler) extends HttpApp
     *
     * @return Server route that either maps to 200 OK or to the respective error codes
     */
-  def matchInstance(callerId: Long, matchingResult: Boolean, matchedInstanceId: Long): server.Route = {
+  def matchInstance(callerId: Long, matchingResultStr: String, matchedInstanceIdStr: String): server.Route = {
     authenticateOAuth2[AccessToken]("Secure Site", AuthProvider.authenticateOAuthRequire(_, userType = UserType.Component)) { token =>
+
+      val matchingResult: Boolean = matchingResultStr.toBoolean
+      val matchedInstanceId: Long = matchedInstanceIdStr.toLong
       post {
-        log.debug(s"POST /matchingResult?callerId=$callerId&matchedInstanceId=$matchedInstanceId&MatchingSuccessful=$matchingResult has been called")
+        log.debug(s"POST /instances/$callerId/matchingResult has been called with parameters : matchedInstanceId=$matchedInstanceId&MatchingSuccessful=$matchingResult")
 
         handler.handleMatchingResult(callerId, matchedInstanceId, matchingResult) match {
           case handler.OperationResult.IdUnknown =>
@@ -395,9 +397,9 @@ class Server(handler: RequestHandler) extends HttpApp
     authenticateOAuth2[AccessToken]("Secure Site", AuthProvider.authenticateOAuthRequire(_, userType = UserType.Admin)) { token =>
       post {
         if (name.isEmpty) {
-          log.debug(s"POST /deploy?ComponentType=$compTypeString has been called")
+          log.debug(s"POST /instances/deploy?ComponentType=$compTypeString has been called")
         } else {
-          log.debug(s"POST /deploy?ComponentType=$compTypeString&name=${name.get} has been called")
+          log.debug(s"POST /instances/deploy?ComponentType=$compTypeString&name=${name.get} has been called")
         }
         val compType: ComponentType = ComponentType.values.find(v => v.toString == compTypeString).orNull
 
@@ -832,7 +834,7 @@ class Server(handler: RequestHandler) extends HttpApp
   def network(): server.Route = {
     authenticateOAuth2[AccessToken]("Secure Site", AuthProvider.authenticateOAuthRequire(_, userType = UserType.User)) { token =>
       get {
-        log.debug(s"GET /network has been called.")
+        log.debug(s"GET /instances/network has been called.")
         complete {
           handler.handleGetNetwork().toJson
         }

src/test/scala/de/upb/cs/swt/delphi/instanceregistry/connection/ServerTest.scala

@@ -392,52 +392,49 @@ class ServerTest
       val id2 = assertValidRegister(ComponentType.WebApi)
 
 
-      /*      Post(s"/instances/$id1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": "true", "SenderId" : $id2}""")) ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
-              assert(status === StatusCodes.OK)
-              responseAs[String] shouldEqual "Matching result true processed."
-            }
-
-            Post(s"/matchingResult?CallerId=$id1&MatchedInstanceId=$id2&MatchingSuccessful=1") ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
-            assert(status === StatusCodes.OK)
-            responseAs[String] shouldEqual "Matching result true processed."
-            }
-      */
+      Post(s"/instances/$id1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": true, "SenderId" : $id2}""")) ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
+        assert(status === StatusCodes.OK)
+        responseAs[String] shouldEqual "Matching result true processed."
+      }
       //Remove Instances
       assertValidDeregister(id1)
       assertValidDeregister(id2)
     }
 
-    /*
+
     //Invalid POST /matchingResult
     "not process matching result if method or parameters are invalid" in {
       //Wrong method
-      Get("/matchingResult?CallerId=0&MatchedInstanceId=0&MatchingSuccessful=1") ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
+
+      Get(s"/instances/0/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": true, "SenderId" : 0}""")) ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
         assert(status === StatusCodes.METHOD_NOT_ALLOWED)
         responseAs[String] shouldEqual "HTTP method not allowed, supported methods: POST"
       }
 
+
       //Invalid IDs - expect 404
-      Post("/matchingResult?CallerId=1&MatchedInstanceId=2&MatchingSuccessful=0") ~> addAuthorization("Component") ~> server.routes ~> check {
+      Post(s"/instances/1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": false, "SenderId" : 2}""")) ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
         assert(status === StatusCodes.NOT_FOUND)
       }
 
-      //Wrong parameters, caller is same as callee - expect bad request
-      Post("/matchingResult?CallerId=0&MatchedInstanceId=0&MatchingSuccessful=O") ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
-        assert(status === StatusCodes.BAD_REQUEST)
-      }
+      /*  //Wrong parameters, caller is same as callee - expect bad request
+       // Post("/matchingResult?CallerId=0&MatchedInstanceId=0&MatchingSuccessful=O") ~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
+         Post(s"/instances/1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": false, "SenderId" : 1}"""))~> addAuthorization("Component") ~> Route.seal(server.routes) ~> check {
+          assert(status === StatusCodes.BAD_REQUEST)
+        }*/
 
       //Wrong user type
-      Post("/matchingResult?CallerId=1&MatchedInstanceId=2&MatchingSuccessful=0") ~> addAuthorization("User") ~> Route.seal(server.routes) ~> check {
+      Post(s"/instances/1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": false, "SenderId" : 2}""")) ~> addAuthorization("User") ~> Route.seal(server.routes) ~> check {
         assert(status === StatusCodes.UNAUTHORIZED)
         responseAs[String] shouldEqual "The supplied authentication is invalid"
       }
 
       //No authorization
-      Post("/matchingResult?CallerId=1&MatchedInstanceId=2&MatchingSuccessful=0") ~> Route.seal(server.routes) ~> check {
+      Post(s"/instances/1/matchingResult", HttpEntity(ContentTypes.`application/json`, s"""{ "MatchingSuccessful": false, "SenderId" : 2}""")) ~> Route.seal(server.routes) ~> check {
         assert(status === StatusCodes.UNAUTHORIZED)
-        responseAs[String].toLowerCase should include ("not supplied with the request")
+        responseAs[String].toLowerCase should include("not supplied with the request")
       }
-    }*/
+    }
 
     //Valid GET /eventList
     "returns registry events that are associated to the instance if id is valid" in {