Fixed Ktor.lpfcpServer()

Author: likespro

build.gradle.kts

@@ -55,6 +55,7 @@ allprojects {
 
     repositories {
         mavenCentral()
+        mavenLocal() // For easier testing
     }
 }
 

core/src/main/java/eth/likespro/lpfcp/LPFCP.kt

@@ -8,10 +8,9 @@
 
 package eth.likespro.lpfcp
 
-import eth.likespro.commons.reflection.ObjectEncoding.decodeObject
 import eth.likespro.commons.models.EncodableResult
 import eth.likespro.commons.network.HTTPUtils.post
-import eth.likespro.commons.reflection.ReflectionUtils.boxed
+import eth.likespro.commons.reflection.ObjectEncoding.decodeObject
 import eth.likespro.commons.reflection.ReflectionUtils.getParametrizedType
 import org.json.JSONException
 import org.json.JSONObject

examples/calculator-java/.idea/vcs.xml

@@ -32,7 +32,7 @@ object Ktor {
          * @param wait Specifies whether to block the current thread until the engine stops. Defaults to true.
          * @return The instance of the started NettyApplicationEngine.
          */
-        fun start(wait: Boolean): LPFCPServer = this.apply { embeddedServer.engine.start(wait) }
+        fun start(wait: Boolean): LPFCPServer = this.apply { embeddedServer.start(wait) }
 
         /**
          * Stops the Netty application engine with the specified grace period and timeout.

ktor/src/main/java/eth/likespro/lpfcp/ktor/Ktor.kt

@@ -41,11 +41,12 @@ class KtorTests {
             override fun divideSafely(a: Int, b: Int): Int? = if (b == 0) null else a / b
         }
 
+        val port = 8090
         var server: Ktor.LPFCPServer? = null
 
         @JvmStatic
         @BeforeAll fun setupKtorServer() {
-            server = lpfcpServer(calculator).start(wait = false)
+            server = lpfcpServer(calculator, port).start(wait = false)
         }
 
         @JvmStatic
@@ -65,43 +66,43 @@ class KtorTests {
 
 
     @Test fun ktorServer_withValidFunctionWithNoArgsAndNoArgs_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>(URI("http://localhost:8080/lpfcp"))
+        val processor = LPFCP.getProcessor<Calculator>(URI("http://localhost:$port/lpfcp"))
         val response = processor.hello()
         assertEquals("Hello, World!", response)
     }
 
     @Test fun ktorServer_withValidFunctionAndArgs_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         val response = processor.add(3, 5)
         assertEquals(8, response)
     }
 
     @Test fun getProcessor_withLambda_proceedsRequest_withValidFunctionReturningNullAndArgs_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         val response = processor.divideSafely(3, 0)
         assertEquals(null, response)
     }
 
     @Test fun getProcessor_withLambda_proceedsRequest_withValidOverloadedFunctionAndArgs_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         val response = processor.add("3", "5")
         assertEquals("35", response)
     }
 
     @Test fun getProcessor_withLambda_proceedsRequest_withValidFunctionWithDefaultArgsAndArgs_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         val response = processor.add(b = "5")
         assertEquals("15", response)
     }
 
     @Test fun getProcessor_withLambda_proceedsRequest_withValidFunctionWithDefaultArgsAndArgsInReverseOrder_returnsSuccess() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         val response = processor.add(b = "5", a = "4")
         assertEquals("45", response)
     }
 
     @Test fun getProcessor_withLambda_proceedsRequest_withFunctionThrowingException_returnsArithmeticException() {
-        val processor = LPFCP.getProcessor<Calculator>("http://localhost:8080/lpfcp")
+        val processor = LPFCP.getProcessor<Calculator>("http://localhost:$port/lpfcp")
         assertEquals(
             ArithmeticException::class.java,
             assertThrows<WrappedException.Exception> { processor.divide(5, 0) }.wrappedException.exceptionClass

ktor/src/test/java/eth/likespro/lpfcp/ktor/KtorTests.kt

@@ -1,5 +1,6 @@
 package eth.likespro.lpfcp.ktor;
 
+import eth.likespro.commons.models.WrappedException;
 import eth.likespro.lpfcp.LPFCP;
 import eth.likespro.lpfcp.LPFCPJava;
 import org.junit.jupiter.api.AfterAll;
@@ -55,10 +56,11 @@ public Integer divideSafely(int a, int b) {
     }
 
     public static CalculatorImpl calculator = new CalculatorImpl();
+    public static Integer port = 8090;
     public static Ktor.LPFCPServer server;
 
     @BeforeAll static void setupKtorServer() {
-        server = Ktor.INSTANCE.lpfcpServer(calculator, 8080, false).start(false);
+        server = Ktor.INSTANCE.lpfcpServer(calculator, port, WrappedException.DetailsConfiguration.Companion.getINCLUDE_ALL()).start(false);
     }
 
     @AfterAll static void teardownKtorServer() {
@@ -76,13 +78,13 @@ public Integer divideSafely(int a, int b) {
 
 
     @Test public void ktorServer_withValidFunctionWithNoArgsAndNoArgs_returnsSuccess() throws URISyntaxException {
-        Calculator processor = LPFCPJava.getProcessor(Calculator.class, new URI("http://localhost:8080/lpfcp"));
+        Calculator processor = LPFCPJava.getProcessor(Calculator.class, new URI("http://localhost:" + port + "/lpfcp"));
         String response = processor.hello();
         assertEquals("Hello, World!", response);
     }
 
     @Test public void ktorServer_withValidFunctionAndArgs_returnsSuccess() {
-        Calculator processor = LPFCPJava.getProcessor(Calculator.class, "http://localhost:8080/lpfcp");
+        Calculator processor = LPFCPJava.getProcessor(Calculator.class, "http://localhost:" + port + "/lpfcp");
         Integer response = processor.add(3, 5);
         assertEquals(8, response);
     }