From 554120af5c36c5479e311d27d588a8415a3b93f4 Mon Sep 17 00:00:00 2001 From: ycombes Date: Thu, 29 Aug 2019 17:16:20 +0200 Subject: [PATCH 01/14] add unit tests --- .../io/kuzzle/runner/CoreClasses/GObject.java | 310 ++++++++++++++++++ .../kuzzle/runner/Helpers/IJObjectHelper.java | 22 ++ .../test/java/io/kuzzle/runner/Kuzzle.java | 20 ++ .../io/kuzzle/runner/Protocol/WebSocket.java | 19 ++ .../test/CoreClasses/TaskTest/TaskTests.java | 151 +++++++++ .../CoreClasses/TaskTest/TestableTask.java | 32 ++ .../test/EventsTest/EventListenerTests.java | 159 +++++++++ .../EventsTest/TestableEventListener.java | 22 ++ .../io/kuzzle/test/Helpers/DefaultTests.java | 24 ++ .../test/java/io/kuzzle/test/KuzzleTests.java | 177 ++++++++++ .../test/ProtocolTest/TestableWebSocket.java | 40 +++ .../test/ProtocolTest/WebSocketTests.java | 90 +++++ .../java/io/kuzzle/test/TestableKuzzle.java | 51 +++ 13 files changed, 1117 insertions(+) create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java create mode 100644 kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java new file mode 100644 index 00000000..0dd30478 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java @@ -0,0 +1,310 @@ +package io.kuzzle.runner.CoreClasses; + +import com.google.gson.JsonElement; +import com.google.gson.JsonNull; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.CoreClasses.Json.JsonSerializable; + +public class GObject implements IJObject { + + private JsonObject jsonObject; + + public GObject() { + this.jsonObject = new JsonObject(); + } + + public GObject(JsonObject jsonObject) { + this.jsonObject = jsonObject; + } + + @Override + public void put(String property, Byte value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Short value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Integer value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Long value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, String value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Double value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Float value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Boolean value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Character value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, IJObject value) { + if (value != null) { + jsonObject.add( + property, + new JsonParser().parse(value.toJsonString()) + ); + } else { + jsonObject.add(property, new JsonNull()); + } + } + + @Override + public void put(String property, Object value) { + if (value == null) { + jsonObject.add(property, new JsonNull()); + } else if (value instanceof JsonElement) { + jsonObject.add(property, (JsonElement)value); + } else if (value instanceof JsonSerializable) { + put(property, ((JsonSerializable) value).toIJObject()); + } + } + + @Override + public Byte getByte(String property) { + return jsonObject.has(property) + ? jsonObject.get(property).getAsByte() + : null; + } + + @Override + public Short getShort(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsShort() + : null; + } + + @Override + public Integer getInteger(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsInt() + : null; + } + + @Override + public Long getLong(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsLong() + : null; + } + + @Override + public Double getDouble(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsDouble() + : null; + } + + @Override + public Float getFloat(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsFloat() + : null; + } + + @Override + public String getString(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsString() + : null; + } + + @Override + public Boolean getBoolean(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsBoolean() + : null; + } + + @Override + public Character getCharacter(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsCharacter() + : null; + } + + @Override + public IJObject getIJObject(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonObject() + ? new GObject(jsonObject.getAsJsonObject(property)) + : null; + } + + @Override + public Object get(String property) { + return !isNull(property) + ? jsonObject.get(property) + : null; + } + + @Override + public byte optByte(String property, byte defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsByte() + : defaultValue; + } + + @Override + public short optShort(String property, short defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsShort() + : defaultValue; + } + + @Override + public int optInteger(String property, int defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsInt() + : defaultValue; + } + + @Override + public long optLong(String property, long defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsLong() + : defaultValue; + } + + @Override + public double optDouble(String property, double defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsDouble() + : defaultValue; + } + + @Override + public float optFloat(String property, float defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsFloat() + : defaultValue; + } + + @Override + public String optString(String property, String defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsString() + : defaultValue; + } + + @Override + public boolean optBoolean(String property, boolean defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsBoolean() + : defaultValue; + } + + @Override + public char optCharacter(String property, char defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsCharacter() + : defaultValue; + } + + @Override + public IJObject optIJObject(String property, IJObject defaultValue) { + return !isNull(property) + && jsonObject.get(property).isJsonObject() + ? new GObject(jsonObject.getAsJsonObject(property)) + : defaultValue; + } + + @Override + public Object opt(String property, Object defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsByte() + : defaultValue; + } + + @Override + public boolean has(String property) { + return jsonObject.has(property); + } + + @Override + public Object remove(String property) { + return null; + } + + @Override + public boolean isNull(String property) { + return !jsonObject.has(property) + || jsonObject.get(property).isJsonNull(); + } + + @Override + public boolean isIJObject(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonObject(); + } + + @Override + public boolean isJsonArray(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonArray(); + } + + @Override + public String toJsonString() { + return jsonObject.toString(); + } + + @Override + public int size() { + return jsonObject.size(); + } + + @Override + public JsonObject toNative() { + return jsonObject; + } + + @Override + public IJObject newIJObject() { + return new GObject(); + } + + @Override + public IJObject newIJObject(JsonObject json) { + return new GObject(json); + } + + @Override + public IJObject parse(String jsonString) { + JsonElement json = new JsonParser().parse(jsonString); + if (json != null + && !json.isJsonNull() + && json.isJsonObject() + ) { + return new GObject(json.getAsJsonObject()); + } + return new GObject(); + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java new file mode 100644 index 00000000..956b99fd --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java @@ -0,0 +1,22 @@ +package io.kuzzle.runner.Helpers; + +import io.kuzzle.runner.CoreClasses.GObject; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; + +public class IJObjectHelper { + + private static IJObject jsonConstructor = new GObject(); + + public static IJObject newIJObject() { + return jsonConstructor.newIJObject(); + } + + public static IJObject newIJObject(T json) { + return jsonConstructor.newIJObject(json); + } + + public static IJObject parse(String json) { + return jsonConstructor.parse(json); + } + +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java new file mode 100644 index 00000000..56d0fc06 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java @@ -0,0 +1,20 @@ +package io.kuzzle.runner; + +import io.kuzzle.runner.Helpers.IJObjectHelper; +import io.kuzzle.sdk.AbstractKuzzle; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.Options.KuzzleOptions; +import io.kuzzle.sdk.Protocol.AbstractProtocol; + +import java.net.URISyntaxException; + +public class Kuzzle extends AbstractKuzzle { + public Kuzzle(AbstractProtocol networkProtocol) + throws IllegalArgumentException { + super((IJObject)IJObjectHelper.newIJObject(), networkProtocol); + } + + public Kuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { + super((IJObject) IJObjectHelper.newIJObject(), networkProtocol, options); + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java new file mode 100644 index 00000000..0bede991 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java @@ -0,0 +1,19 @@ +package io.kuzzle.runner.Protocol; + +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.AbstractWebSocket; + +import java.net.URISyntaxException; + +public class WebSocket extends AbstractWebSocket { + + public WebSocket(String host) + throws URISyntaxException, IllegalArgumentException { + super(host); + } + + public WebSocket(String host, WebSocketOptions options) + throws URISyntaxException, IllegalArgumentException { + super(host, options); + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java new file mode 100644 index 00000000..21c6d0c9 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java @@ -0,0 +1,151 @@ +package io.kuzzle.test.CoreClasses.TaskTest; + +import io.kuzzle.sdk.CoreClasses.Task; +import org.junit.Assert; +import org.junit.Test; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.*; + +public class TaskTests { + + @Test + public void constructorTest() { + TestableTask task = new TestableTask<>(); + Assert.assertNotNull(task.getAtomicReference()); + Assert.assertEquals( + AtomicReference.class, + task.getAtomicReference().getClass() + ); + Assert.assertNotNull(task.getCountDownLatch()); + Assert.assertEquals( + CountDownLatch.class, + task.getCountDownLatch().getClass() + ); + Assert.assertNotNull(task.getFuture()); + } + + @Test + public void getFutureTest() { + Task task = new Task<>(); + + Assert.assertEquals( + CompletableFuture.class, + task.getFuture().getClass() + ); + } + + @Test + public void setExceptionTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + task.setException(new Exception("foobar")); + + verify( + task.mockedFuture, + times(1) + ).completeExceptionally(any(Exception.class)); + } + + @Test + public void isCancelledTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isCancelled()) + .thenReturn(true); + + Assert.assertTrue(task.isCancelled()); + + verify( + task.mockedFuture, + times(1) + ).isCancelled(); + } + + @Test + public void isDoneTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isDone()) + .thenReturn(true); + + Assert.assertTrue(task.isDone()); + + verify( + task.mockedFuture, + times(1) + ).isDone(); + } + + @Test + public void isCompletedExceptionallyTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isCompletedExceptionally()) + .thenReturn(true); + + Assert.assertTrue(task.isCompletedExceptionally()); + + verify( + task.mockedFuture, + times(1) + ).isCompletedExceptionally(); + } + + @Test + public void setCancelledTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + task.setCancelled(true); + + verify( + task.mockedFuture, + times(1) + ).cancel(anyBoolean()); + } + + @Test + public void triggerTest() { + Task task = new Task(); + + final AtomicBoolean success = new AtomicBoolean(false); + + CompletableFuture taskChain = task.getFuture().thenRun(() -> { + success.set(true); + }); + + task.trigger(); + + taskChain.join(); + + Assert.assertTrue(success.get()); + + } + + @Test + public void triggerWithObjectTest() { + Task task = new Task(); + + final AtomicBoolean success = new AtomicBoolean(false); + + CompletableFuture taskChain = task.getFuture().thenAccept((str) -> { + success.set(str.equals("foobar")); + }); + + task.trigger("foobar"); + + taskChain.join(); + + Assert.assertTrue(success.get()); + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java new file mode 100644 index 00000000..51852112 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java @@ -0,0 +1,32 @@ +package io.kuzzle.test.CoreClasses.TaskTest; + +import io.kuzzle.sdk.CoreClasses.Task; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicReference; + +import static org.mockito.Mockito.mock; + +public class TestableTask extends Task { + public CountDownLatch mockedCountDownLatch = mock(CountDownLatch.class); + public CompletableFuture mockedFuture = mock(CompletableFuture.class); + + public TestableTask() { + super(); + } + + public void applyMockFuture() { + super.future = mockedFuture; + } + + public CountDownLatch getCountDownLatch() { + return super.countDownLatch; + } + + public AtomicReference getAtomicReference() { + return super.atomicReference; + } + + +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java new file mode 100644 index 00000000..ec22a31f --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java @@ -0,0 +1,159 @@ +package io.kuzzle.test.EventsTest; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +public class EventListenerTests { + + @Test + public void registerRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.register(() -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).add(any(Runnable.class)); + } + + @Test + public void unregisterRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.unregister(() -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).remove(any(Runnable.class)); + } + + @Test + public void registerConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.register((obj) -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).add(any(Consumer.class)); + } + + @Test + public void unregisterConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.unregister((obj) -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).remove(any(Consumer.class)); + } + + @Test + public void registerDuplicateTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + Runnable runnable1 = () -> {}; + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(() -> {}); + + Assert.assertEquals(2, eventListener.getCallbacks().size()); + } + + @Test + public void triggerRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean success = new AtomicBoolean(false); + eventListener.register(() -> success.set(true)); + + Assert.assertFalse(success.get()); + + eventListener.trigger(); + + Assert.assertTrue(success.get()); + } + + @Test + public void triggerConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean success = new AtomicBoolean(false); + eventListener.register((str) -> success.set(str.equals("foobar"))); + + Assert.assertFalse(success.get()); + + eventListener.trigger("foobar"); + + Assert.assertTrue(success.get()); + } + + @Test + public void triggerOnlyConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean consumerSuccess = new AtomicBoolean(false); + AtomicBoolean runnableSuccess = new AtomicBoolean(false); + + eventListener.register((str) -> consumerSuccess.set(str.equals("foobar"))); + eventListener.register(() -> runnableSuccess.set(true)); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + + eventListener.trigger("foobar"); + + Assert.assertTrue(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + } + + @Test + public void triggerOnlyRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean consumerSuccess = new AtomicBoolean(false); + AtomicBoolean runnableSuccess = new AtomicBoolean(false); + + eventListener.register( + (str) -> consumerSuccess.set(str.equals("foobar")) + ); + eventListener.register(() -> runnableSuccess.set(true)); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + + eventListener.trigger(); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertTrue(runnableSuccess.get()); + } + +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java new file mode 100644 index 00000000..3d1af9e3 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java @@ -0,0 +1,22 @@ +package io.kuzzle.test.EventsTest; + +import io.kuzzle.sdk.Events.EventListener; + +import java.util.Set; + +import static org.mockito.Mockito.mock; + +public class TestableEventListener extends EventListener { + public Set mockedCallbacks = mock(Set.class); + public TestableEventListener() { + super(); + } + + public void applyMock() { + super.callbacks = mockedCallbacks; + } + + public Set getCallbacks() { + return super.callbacks; + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java new file mode 100644 index 00000000..a54da7fc --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java @@ -0,0 +1,24 @@ +package io.kuzzle.test.Helpers; + +import io.kuzzle.sdk.Helpers.Default; +import org.junit.Assert; +import org.junit.Test; + +public class DefaultTests { + + @Test + public void notNullTest() { + String str1 = Default.notNull(null, "foobar"); + String str2 = Default.notNull("SomeString", "foobar"); + + Integer int1 = Default.notNull(null, 42); + Integer int2 = Default.notNull(10, 42); + + Assert.assertEquals("foobar", str1); + Assert.assertEquals("SomeString", str2); + + Assert.assertEquals(42, int1.intValue()); + Assert.assertEquals(10, int2.intValue()); + } + +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java new file mode 100644 index 00000000..c950a218 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java @@ -0,0 +1,177 @@ +package io.kuzzle.test; + +import io.kuzzle.runner.Helpers.IJObjectHelper; +import io.kuzzle.runner.Protocol.WebSocket; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.CoreClasses.Task; +import io.kuzzle.sdk.Events.EventListener; +import io.kuzzle.sdk.Exceptions.InternalException; +import io.kuzzle.sdk.Exceptions.NotConnectedException; +import io.kuzzle.sdk.Protocol.AbstractProtocol; +import io.kuzzle.sdk.Protocol.ProtocolState; +import io.kuzzle.sdk.CoreClasses.Responses.ErrorResponse; +import io.kuzzle.sdk.CoreClasses.Responses.Response; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Matchers; +import org.mockito.Mockito; +import org.mockito.stubbing.Answer; + +import java.net.URISyntaxException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicBoolean; + +public class KuzzleTests { + private AbstractProtocol networkProtocol = Mockito.mock(WebSocket.class); + private EventListener + tokenExpiredEventListener = Mockito.mock(EventListener.class); + private EventListener> + unhandledResponseEventListener = Mockito.mock(EventListener.class); + private TestableKuzzle kuzzle; + + @Before + public void setup() throws URISyntaxException { + kuzzle = new TestableKuzzle(networkProtocol); + kuzzle.setTokenExpiredEventListener(tokenExpiredEventListener); + kuzzle.setUnhandledResponseEventListener(unhandledResponseEventListener); + } + + @Test + public void connect() throws Exception { + kuzzle.connect(); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).connect(); + } + + @Test + public void disconnect() throws Exception { + kuzzle.disconnect(); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).disconnect(); + } + + + @Test + public void registerTokenExpiredEvent() throws Exception { + kuzzle.registerTokenExpiredEvent(() -> {}); + Mockito.verify(tokenExpiredEventListener, + Mockito.times(1) + ).register(Matchers.any(Runnable.class)); + } + + @Test + public void unregisterTokenExpiredEvent() throws Exception { + kuzzle.unregisterTokenExpiredEvent(() -> {}); + Mockito.verify( + tokenExpiredEventListener, + Mockito.times(1) + ).unregister(Matchers.any(Runnable.class)); + } + + @Test + public void onStateChanged() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + Task> response = new Task<>(); + requests.put("foobar", response); + kuzzle.onStateChanged(ProtocolState.CLOSE); + Assert.assertEquals(0, requests.size()); + Assert.assertTrue(response.isCompletedExceptionally()); + } + + @Test(expected = NotConnectedException.class) + public void queryShouldThrowWhenNotConnected() + throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.CLOSE + ); + + kuzzle.query(IJObjectHelper.newIJObject().toNative()); + } + + @Test + public void querySuccess() throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.OPEN + ); + + CompletableFuture> + response = kuzzle.query( + IJObjectHelper.newIJObject().toNative() + ); + + Assert.assertNotNull(response); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).send(Matchers.any(IJObject.class)); + } + + @Test(expected = InternalException.class) + public void queryShouldThrowWhenVolatileIsNotIJObject() + throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.OPEN + ); + + IJObject payload = IJObjectHelper.newIJObject(); + payload.put("volatile", "foobar"); + + kuzzle.query(payload.toNative()); + } + + @Test + public void onResponseReceivedAndTokenIsExpired() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + Response response = new Response(); + response.error = new ErrorResponse(); + response.error.message = "Token expired"; + response.error.status = 42; + response.room = "room-id"; + + Task> task = new Task>(); + + requests.put("room-id", task); + + kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + + Mockito.verify( + tokenExpiredEventListener, + Mockito.times(1) + ).trigger(); + } + + @Test + public void onResponseReceivedAndResponseIsUnhandled() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + AtomicBoolean success = new AtomicBoolean(false); + Response response = new Response(); + response.requestId = "foobar"; + + Task> task = new Task>(); + + requests.put("request-id", task); + + kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + + Mockito.verify( + unhandledResponseEventListener, + Mockito.times(1) + ).trigger(Matchers.any(Response.class)); + } + +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java new file mode 100644 index 00000000..0dd2e2dd --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java @@ -0,0 +1,40 @@ +package io.kuzzle.test.ProtocolTest; + +import io.kuzzle.runner.Protocol.WebSocket; +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.ProtocolState; + +import java.io.IOException; +import java.net.URISyntaxException; + +import static org.mockito.Mockito.mock; + +public class TestableWebSocket extends WebSocket { + public int stateChangedCount = 0; + public ProtocolState lastStateDispatched = ProtocolState.CLOSE; + public com.neovisionaries.ws.client.WebSocket + mockedSocket = mock(com.neovisionaries.ws.client.WebSocket.class); + + public TestableWebSocket(String host) + throws URISyntaxException, IllegalArgumentException { + super(host); + } + + public TestableWebSocket(String host, WebSocketOptions options) + throws URISyntaxException, IllegalArgumentException { + super(host, options); + super.stateChanged.register((ProtocolState state) -> { + stateChangedCount += 1; + lastStateDispatched = state; + }); + } + + public com.neovisionaries.ws.client.WebSocket getSocket() { + return super.socket; + } + + @Override + protected com.neovisionaries.ws.client.WebSocket createClientSocket() { + return mockedSocket; + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java new file mode 100644 index 00000000..06ce7bbb --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java @@ -0,0 +1,90 @@ +package io.kuzzle.test.ProtocolTest; + +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.ProtocolState; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.net.URISyntaxException; + +import static org.mockito.Mockito.*; + +public class WebSocketTests { + + private TestableWebSocket socket; + private String host; + private WebSocketOptions options; + + @Before + public void setup() throws URISyntaxException { + host = "foo"; + options = new WebSocketOptions() + .withPort(1234) + .withSsl(true); + socket = new TestableWebSocket<>(host, options); + } + + @Test + public void constructorNotConnected() throws URISyntaxException { + TestableWebSocket ws = new TestableWebSocket<>(host, options); + + Assert.assertEquals(ProtocolState.CLOSE, ws.getState()); + Assert.assertNull(ws.getSocket()); + } + + @Test(expected = IllegalArgumentException.class) + public void constructorRejectsNullHost() throws URISyntaxException { + TestableWebSocket ws = new TestableWebSocket<>(null, options); + } + + @Test + public void connectTest() throws Exception { + when(socket.mockedSocket.connect()).thenAnswer(invocation -> null); + + socket.connect(); + + Assert.assertNotNull(socket.getSocket()); + + socket.connect(); + socket.connect(); + socket.connect(); + + verify(socket.mockedSocket, times(1)).connect(); + + Assert.assertEquals(ProtocolState.OPEN, socket.getState()); + Assert.assertEquals(1, socket.stateChangedCount); + Assert.assertEquals(ProtocolState.OPEN, socket.lastStateDispatched); + } + + @Test + public void disconnectTest() throws Exception { + when(socket.mockedSocket.connect()).thenAnswer(invocation -> null); + + socket.connect(); + + Assert.assertEquals(ProtocolState.OPEN, socket.getState()); + Assert.assertEquals(1, socket.stateChangedCount); + Assert.assertEquals(ProtocolState.OPEN, socket.lastStateDispatched); + + socket.disconnect(); + socket.disconnect(); + socket.disconnect(); + + verify( + socket.mockedSocket, + times(1) + ).disconnect(); + } + + @Test + public void disconnectWithoutEverConnecting() throws Exception { + Assert.assertEquals(ProtocolState.CLOSE, socket.getState()); + Assert.assertEquals(0, socket.stateChangedCount); + + socket.disconnect(); + + Assert.assertEquals(ProtocolState.CLOSE, socket.getState()); + Assert.assertEquals(0, socket.stateChangedCount); + } +} diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java new file mode 100644 index 00000000..6c8e94b7 --- /dev/null +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java @@ -0,0 +1,51 @@ +package io.kuzzle.test; + +import io.kuzzle.runner.Kuzzle; +import io.kuzzle.sdk.CoreClasses.Task; +import io.kuzzle.sdk.Events.EventListener; +import io.kuzzle.sdk.Options.KuzzleOptions; +import io.kuzzle.sdk.Protocol.AbstractProtocol; +import io.kuzzle.sdk.Protocol.ProtocolState; +import io.kuzzle.sdk.CoreClasses.Responses.Response; + +import java.net.URISyntaxException; +import java.util.concurrent.ConcurrentHashMap; + +public class TestableKuzzle extends Kuzzle { + + public TestableKuzzle(AbstractProtocol networkProtocol) throws URISyntaxException, IllegalArgumentException { + super(networkProtocol); + } + + public TestableKuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { + super(networkProtocol, options); + } + + public void setTokenExpiredEventListener(EventListener eventListener) { + super.tokenExpiredEvent = eventListener; + } + + public EventListener getTokenExpiredEventListener() { + return super.tokenExpiredEvent; + } + + public void setUnhandledResponseEventListener(EventListener eventListener) { + super.unhandledResponseEvent = eventListener; + } + + public EventListener getUnhandledResponseEventListener() { + return super.unhandledResponseEvent; + } + + public void onStateChanged(ProtocolState state) { + super.onStateChanged(state); + } + + public void onResponseReceived(String payload) { + super.onResponseReceived(payload); + } + + public ConcurrentHashMap>> getRequests() { + return super.requests; + } +} From aceb4d39a712220f7c80019a9d2464d84c03c7fc Mon Sep 17 00:00:00 2001 From: ycombes Date: Thu, 29 Aug 2019 17:28:57 +0200 Subject: [PATCH 02/14] add unit tests --- .../io/kuzzle/runner/CoreClasses/GObject.java | 310 ++++++++++++++++++ .../kuzzle/runner/Helpers/IJObjectHelper.java | 22 ++ .../test/java/io/kuzzle/runner/Kuzzle.java | 20 ++ .../io/kuzzle/runner/Protocol/WebSocket.java | 19 ++ .../test/CoreClasses/TaskTest/TaskTests.java | 151 +++++++++ .../CoreClasses/TaskTest/TestableTask.java | 32 ++ .../test/EventsTest/EventListenerTests.java | 159 +++++++++ .../EventsTest/TestableEventListener.java | 22 ++ .../io/kuzzle/test/Helpers/DefaultTests.java | 24 ++ .../test/java/io/kuzzle/test/KuzzleTests.java | 177 ++++++++++ .../test/ProtocolTest/TestableWebSocket.java | 40 +++ .../test/ProtocolTest/WebSocketTests.java | 90 +++++ .../java/io/kuzzle/test/TestableKuzzle.java | 51 +++ 13 files changed, 1117 insertions(+) create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java create mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java new file mode 100644 index 00000000..0dd30478 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java @@ -0,0 +1,310 @@ +package io.kuzzle.runner.CoreClasses; + +import com.google.gson.JsonElement; +import com.google.gson.JsonNull; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.CoreClasses.Json.JsonSerializable; + +public class GObject implements IJObject { + + private JsonObject jsonObject; + + public GObject() { + this.jsonObject = new JsonObject(); + } + + public GObject(JsonObject jsonObject) { + this.jsonObject = jsonObject; + } + + @Override + public void put(String property, Byte value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Short value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Integer value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Long value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, String value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Double value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Float value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Boolean value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, Character value) { + jsonObject.addProperty(property, value); + } + + @Override + public void put(String property, IJObject value) { + if (value != null) { + jsonObject.add( + property, + new JsonParser().parse(value.toJsonString()) + ); + } else { + jsonObject.add(property, new JsonNull()); + } + } + + @Override + public void put(String property, Object value) { + if (value == null) { + jsonObject.add(property, new JsonNull()); + } else if (value instanceof JsonElement) { + jsonObject.add(property, (JsonElement)value); + } else if (value instanceof JsonSerializable) { + put(property, ((JsonSerializable) value).toIJObject()); + } + } + + @Override + public Byte getByte(String property) { + return jsonObject.has(property) + ? jsonObject.get(property).getAsByte() + : null; + } + + @Override + public Short getShort(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsShort() + : null; + } + + @Override + public Integer getInteger(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsInt() + : null; + } + + @Override + public Long getLong(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsLong() + : null; + } + + @Override + public Double getDouble(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsDouble() + : null; + } + + @Override + public Float getFloat(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsFloat() + : null; + } + + @Override + public String getString(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsString() + : null; + } + + @Override + public Boolean getBoolean(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsBoolean() + : null; + } + + @Override + public Character getCharacter(String property) { + return !isNull(property) + ? jsonObject.get(property).getAsCharacter() + : null; + } + + @Override + public IJObject getIJObject(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonObject() + ? new GObject(jsonObject.getAsJsonObject(property)) + : null; + } + + @Override + public Object get(String property) { + return !isNull(property) + ? jsonObject.get(property) + : null; + } + + @Override + public byte optByte(String property, byte defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsByte() + : defaultValue; + } + + @Override + public short optShort(String property, short defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsShort() + : defaultValue; + } + + @Override + public int optInteger(String property, int defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsInt() + : defaultValue; + } + + @Override + public long optLong(String property, long defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsLong() + : defaultValue; + } + + @Override + public double optDouble(String property, double defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsDouble() + : defaultValue; + } + + @Override + public float optFloat(String property, float defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsFloat() + : defaultValue; + } + + @Override + public String optString(String property, String defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsString() + : defaultValue; + } + + @Override + public boolean optBoolean(String property, boolean defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsBoolean() + : defaultValue; + } + + @Override + public char optCharacter(String property, char defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsCharacter() + : defaultValue; + } + + @Override + public IJObject optIJObject(String property, IJObject defaultValue) { + return !isNull(property) + && jsonObject.get(property).isJsonObject() + ? new GObject(jsonObject.getAsJsonObject(property)) + : defaultValue; + } + + @Override + public Object opt(String property, Object defaultValue) { + return !isNull(property) + ? jsonObject.get(property).getAsByte() + : defaultValue; + } + + @Override + public boolean has(String property) { + return jsonObject.has(property); + } + + @Override + public Object remove(String property) { + return null; + } + + @Override + public boolean isNull(String property) { + return !jsonObject.has(property) + || jsonObject.get(property).isJsonNull(); + } + + @Override + public boolean isIJObject(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonObject(); + } + + @Override + public boolean isJsonArray(String property) { + return !isNull(property) + && jsonObject.get(property).isJsonArray(); + } + + @Override + public String toJsonString() { + return jsonObject.toString(); + } + + @Override + public int size() { + return jsonObject.size(); + } + + @Override + public JsonObject toNative() { + return jsonObject; + } + + @Override + public IJObject newIJObject() { + return new GObject(); + } + + @Override + public IJObject newIJObject(JsonObject json) { + return new GObject(json); + } + + @Override + public IJObject parse(String jsonString) { + JsonElement json = new JsonParser().parse(jsonString); + if (json != null + && !json.isJsonNull() + && json.isJsonObject() + ) { + return new GObject(json.getAsJsonObject()); + } + return new GObject(); + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java new file mode 100644 index 00000000..956b99fd --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java @@ -0,0 +1,22 @@ +package io.kuzzle.runner.Helpers; + +import io.kuzzle.runner.CoreClasses.GObject; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; + +public class IJObjectHelper { + + private static IJObject jsonConstructor = new GObject(); + + public static IJObject newIJObject() { + return jsonConstructor.newIJObject(); + } + + public static IJObject newIJObject(T json) { + return jsonConstructor.newIJObject(json); + } + + public static IJObject parse(String json) { + return jsonConstructor.parse(json); + } + +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java new file mode 100644 index 00000000..56d0fc06 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java @@ -0,0 +1,20 @@ +package io.kuzzle.runner; + +import io.kuzzle.runner.Helpers.IJObjectHelper; +import io.kuzzle.sdk.AbstractKuzzle; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.Options.KuzzleOptions; +import io.kuzzle.sdk.Protocol.AbstractProtocol; + +import java.net.URISyntaxException; + +public class Kuzzle extends AbstractKuzzle { + public Kuzzle(AbstractProtocol networkProtocol) + throws IllegalArgumentException { + super((IJObject)IJObjectHelper.newIJObject(), networkProtocol); + } + + public Kuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { + super((IJObject) IJObjectHelper.newIJObject(), networkProtocol, options); + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java new file mode 100644 index 00000000..0bede991 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java @@ -0,0 +1,19 @@ +package io.kuzzle.runner.Protocol; + +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.AbstractWebSocket; + +import java.net.URISyntaxException; + +public class WebSocket extends AbstractWebSocket { + + public WebSocket(String host) + throws URISyntaxException, IllegalArgumentException { + super(host); + } + + public WebSocket(String host, WebSocketOptions options) + throws URISyntaxException, IllegalArgumentException { + super(host, options); + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java new file mode 100644 index 00000000..21c6d0c9 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java @@ -0,0 +1,151 @@ +package io.kuzzle.test.CoreClasses.TaskTest; + +import io.kuzzle.sdk.CoreClasses.Task; +import org.junit.Assert; +import org.junit.Test; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.*; + +public class TaskTests { + + @Test + public void constructorTest() { + TestableTask task = new TestableTask<>(); + Assert.assertNotNull(task.getAtomicReference()); + Assert.assertEquals( + AtomicReference.class, + task.getAtomicReference().getClass() + ); + Assert.assertNotNull(task.getCountDownLatch()); + Assert.assertEquals( + CountDownLatch.class, + task.getCountDownLatch().getClass() + ); + Assert.assertNotNull(task.getFuture()); + } + + @Test + public void getFutureTest() { + Task task = new Task<>(); + + Assert.assertEquals( + CompletableFuture.class, + task.getFuture().getClass() + ); + } + + @Test + public void setExceptionTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + task.setException(new Exception("foobar")); + + verify( + task.mockedFuture, + times(1) + ).completeExceptionally(any(Exception.class)); + } + + @Test + public void isCancelledTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isCancelled()) + .thenReturn(true); + + Assert.assertTrue(task.isCancelled()); + + verify( + task.mockedFuture, + times(1) + ).isCancelled(); + } + + @Test + public void isDoneTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isDone()) + .thenReturn(true); + + Assert.assertTrue(task.isDone()); + + verify( + task.mockedFuture, + times(1) + ).isDone(); + } + + @Test + public void isCompletedExceptionallyTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + when(task.mockedFuture.isCompletedExceptionally()) + .thenReturn(true); + + Assert.assertTrue(task.isCompletedExceptionally()); + + verify( + task.mockedFuture, + times(1) + ).isCompletedExceptionally(); + } + + @Test + public void setCancelledTest() { + TestableTask task = new TestableTask<>(); + task.applyMockFuture(); + + task.setCancelled(true); + + verify( + task.mockedFuture, + times(1) + ).cancel(anyBoolean()); + } + + @Test + public void triggerTest() { + Task task = new Task(); + + final AtomicBoolean success = new AtomicBoolean(false); + + CompletableFuture taskChain = task.getFuture().thenRun(() -> { + success.set(true); + }); + + task.trigger(); + + taskChain.join(); + + Assert.assertTrue(success.get()); + + } + + @Test + public void triggerWithObjectTest() { + Task task = new Task(); + + final AtomicBoolean success = new AtomicBoolean(false); + + CompletableFuture taskChain = task.getFuture().thenAccept((str) -> { + success.set(str.equals("foobar")); + }); + + task.trigger("foobar"); + + taskChain.join(); + + Assert.assertTrue(success.get()); + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java new file mode 100644 index 00000000..51852112 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java @@ -0,0 +1,32 @@ +package io.kuzzle.test.CoreClasses.TaskTest; + +import io.kuzzle.sdk.CoreClasses.Task; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicReference; + +import static org.mockito.Mockito.mock; + +public class TestableTask extends Task { + public CountDownLatch mockedCountDownLatch = mock(CountDownLatch.class); + public CompletableFuture mockedFuture = mock(CompletableFuture.class); + + public TestableTask() { + super(); + } + + public void applyMockFuture() { + super.future = mockedFuture; + } + + public CountDownLatch getCountDownLatch() { + return super.countDownLatch; + } + + public AtomicReference getAtomicReference() { + return super.atomicReference; + } + + +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java new file mode 100644 index 00000000..ec22a31f --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java @@ -0,0 +1,159 @@ +package io.kuzzle.test.EventsTest; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +public class EventListenerTests { + + @Test + public void registerRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.register(() -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).add(any(Runnable.class)); + } + + @Test + public void unregisterRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.unregister(() -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).remove(any(Runnable.class)); + } + + @Test + public void registerConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.register((obj) -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).add(any(Consumer.class)); + } + + @Test + public void unregisterConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + eventListener.applyMock(); + + eventListener.unregister((obj) -> {}); + + verify( + eventListener.mockedCallbacks, + times(1) + ).remove(any(Consumer.class)); + } + + @Test + public void registerDuplicateTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + Runnable runnable1 = () -> {}; + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(runnable1); + eventListener.register(() -> {}); + + Assert.assertEquals(2, eventListener.getCallbacks().size()); + } + + @Test + public void triggerRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean success = new AtomicBoolean(false); + eventListener.register(() -> success.set(true)); + + Assert.assertFalse(success.get()); + + eventListener.trigger(); + + Assert.assertTrue(success.get()); + } + + @Test + public void triggerConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean success = new AtomicBoolean(false); + eventListener.register((str) -> success.set(str.equals("foobar"))); + + Assert.assertFalse(success.get()); + + eventListener.trigger("foobar"); + + Assert.assertTrue(success.get()); + } + + @Test + public void triggerOnlyConsumerTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean consumerSuccess = new AtomicBoolean(false); + AtomicBoolean runnableSuccess = new AtomicBoolean(false); + + eventListener.register((str) -> consumerSuccess.set(str.equals("foobar"))); + eventListener.register(() -> runnableSuccess.set(true)); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + + eventListener.trigger("foobar"); + + Assert.assertTrue(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + } + + @Test + public void triggerOnlyRunnableTest() { + TestableEventListener + eventListener = new TestableEventListener<>(); + + AtomicBoolean consumerSuccess = new AtomicBoolean(false); + AtomicBoolean runnableSuccess = new AtomicBoolean(false); + + eventListener.register( + (str) -> consumerSuccess.set(str.equals("foobar")) + ); + eventListener.register(() -> runnableSuccess.set(true)); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertFalse(runnableSuccess.get()); + + eventListener.trigger(); + + Assert.assertFalse(consumerSuccess.get()); + Assert.assertTrue(runnableSuccess.get()); + } + +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java new file mode 100644 index 00000000..3d1af9e3 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java @@ -0,0 +1,22 @@ +package io.kuzzle.test.EventsTest; + +import io.kuzzle.sdk.Events.EventListener; + +import java.util.Set; + +import static org.mockito.Mockito.mock; + +public class TestableEventListener extends EventListener { + public Set mockedCallbacks = mock(Set.class); + public TestableEventListener() { + super(); + } + + public void applyMock() { + super.callbacks = mockedCallbacks; + } + + public Set getCallbacks() { + return super.callbacks; + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java new file mode 100644 index 00000000..a54da7fc --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java @@ -0,0 +1,24 @@ +package io.kuzzle.test.Helpers; + +import io.kuzzle.sdk.Helpers.Default; +import org.junit.Assert; +import org.junit.Test; + +public class DefaultTests { + + @Test + public void notNullTest() { + String str1 = Default.notNull(null, "foobar"); + String str2 = Default.notNull("SomeString", "foobar"); + + Integer int1 = Default.notNull(null, 42); + Integer int2 = Default.notNull(10, 42); + + Assert.assertEquals("foobar", str1); + Assert.assertEquals("SomeString", str2); + + Assert.assertEquals(42, int1.intValue()); + Assert.assertEquals(10, int2.intValue()); + } + +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java new file mode 100644 index 00000000..c950a218 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java @@ -0,0 +1,177 @@ +package io.kuzzle.test; + +import io.kuzzle.runner.Helpers.IJObjectHelper; +import io.kuzzle.runner.Protocol.WebSocket; +import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.CoreClasses.Task; +import io.kuzzle.sdk.Events.EventListener; +import io.kuzzle.sdk.Exceptions.InternalException; +import io.kuzzle.sdk.Exceptions.NotConnectedException; +import io.kuzzle.sdk.Protocol.AbstractProtocol; +import io.kuzzle.sdk.Protocol.ProtocolState; +import io.kuzzle.sdk.CoreClasses.Responses.ErrorResponse; +import io.kuzzle.sdk.CoreClasses.Responses.Response; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Matchers; +import org.mockito.Mockito; +import org.mockito.stubbing.Answer; + +import java.net.URISyntaxException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicBoolean; + +public class KuzzleTests { + private AbstractProtocol networkProtocol = Mockito.mock(WebSocket.class); + private EventListener + tokenExpiredEventListener = Mockito.mock(EventListener.class); + private EventListener> + unhandledResponseEventListener = Mockito.mock(EventListener.class); + private TestableKuzzle kuzzle; + + @Before + public void setup() throws URISyntaxException { + kuzzle = new TestableKuzzle(networkProtocol); + kuzzle.setTokenExpiredEventListener(tokenExpiredEventListener); + kuzzle.setUnhandledResponseEventListener(unhandledResponseEventListener); + } + + @Test + public void connect() throws Exception { + kuzzle.connect(); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).connect(); + } + + @Test + public void disconnect() throws Exception { + kuzzle.disconnect(); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).disconnect(); + } + + + @Test + public void registerTokenExpiredEvent() throws Exception { + kuzzle.registerTokenExpiredEvent(() -> {}); + Mockito.verify(tokenExpiredEventListener, + Mockito.times(1) + ).register(Matchers.any(Runnable.class)); + } + + @Test + public void unregisterTokenExpiredEvent() throws Exception { + kuzzle.unregisterTokenExpiredEvent(() -> {}); + Mockito.verify( + tokenExpiredEventListener, + Mockito.times(1) + ).unregister(Matchers.any(Runnable.class)); + } + + @Test + public void onStateChanged() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + Task> response = new Task<>(); + requests.put("foobar", response); + kuzzle.onStateChanged(ProtocolState.CLOSE); + Assert.assertEquals(0, requests.size()); + Assert.assertTrue(response.isCompletedExceptionally()); + } + + @Test(expected = NotConnectedException.class) + public void queryShouldThrowWhenNotConnected() + throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.CLOSE + ); + + kuzzle.query(IJObjectHelper.newIJObject().toNative()); + } + + @Test + public void querySuccess() throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.OPEN + ); + + CompletableFuture> + response = kuzzle.query( + IJObjectHelper.newIJObject().toNative() + ); + + Assert.assertNotNull(response); + Mockito.verify( + networkProtocol, + Mockito.times(1) + ).send(Matchers.any(IJObject.class)); + } + + @Test(expected = InternalException.class) + public void queryShouldThrowWhenVolatileIsNotIJObject() + throws NotConnectedException, InternalException { + Mockito.when(networkProtocol.getState()) + .thenAnswer( + (Answer) invocation -> ProtocolState.OPEN + ); + + IJObject payload = IJObjectHelper.newIJObject(); + payload.put("volatile", "foobar"); + + kuzzle.query(payload.toNative()); + } + + @Test + public void onResponseReceivedAndTokenIsExpired() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + Response response = new Response(); + response.error = new ErrorResponse(); + response.error.message = "Token expired"; + response.error.status = 42; + response.room = "room-id"; + + Task> task = new Task>(); + + requests.put("room-id", task); + + kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + + Mockito.verify( + tokenExpiredEventListener, + Mockito.times(1) + ).trigger(); + } + + @Test + public void onResponseReceivedAndResponseIsUnhandled() { + ConcurrentHashMap>> + requests = kuzzle.getRequests(); + + AtomicBoolean success = new AtomicBoolean(false); + Response response = new Response(); + response.requestId = "foobar"; + + Task> task = new Task>(); + + requests.put("request-id", task); + + kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + + Mockito.verify( + unhandledResponseEventListener, + Mockito.times(1) + ).trigger(Matchers.any(Response.class)); + } + +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java new file mode 100644 index 00000000..0dd2e2dd --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java @@ -0,0 +1,40 @@ +package io.kuzzle.test.ProtocolTest; + +import io.kuzzle.runner.Protocol.WebSocket; +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.ProtocolState; + +import java.io.IOException; +import java.net.URISyntaxException; + +import static org.mockito.Mockito.mock; + +public class TestableWebSocket extends WebSocket { + public int stateChangedCount = 0; + public ProtocolState lastStateDispatched = ProtocolState.CLOSE; + public com.neovisionaries.ws.client.WebSocket + mockedSocket = mock(com.neovisionaries.ws.client.WebSocket.class); + + public TestableWebSocket(String host) + throws URISyntaxException, IllegalArgumentException { + super(host); + } + + public TestableWebSocket(String host, WebSocketOptions options) + throws URISyntaxException, IllegalArgumentException { + super(host, options); + super.stateChanged.register((ProtocolState state) -> { + stateChangedCount += 1; + lastStateDispatched = state; + }); + } + + public com.neovisionaries.ws.client.WebSocket getSocket() { + return super.socket; + } + + @Override + protected com.neovisionaries.ws.client.WebSocket createClientSocket() { + return mockedSocket; + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java new file mode 100644 index 00000000..06ce7bbb --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java @@ -0,0 +1,90 @@ +package io.kuzzle.test.ProtocolTest; + +import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; +import io.kuzzle.sdk.Protocol.ProtocolState; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.net.URISyntaxException; + +import static org.mockito.Mockito.*; + +public class WebSocketTests { + + private TestableWebSocket socket; + private String host; + private WebSocketOptions options; + + @Before + public void setup() throws URISyntaxException { + host = "foo"; + options = new WebSocketOptions() + .withPort(1234) + .withSsl(true); + socket = new TestableWebSocket<>(host, options); + } + + @Test + public void constructorNotConnected() throws URISyntaxException { + TestableWebSocket ws = new TestableWebSocket<>(host, options); + + Assert.assertEquals(ProtocolState.CLOSE, ws.getState()); + Assert.assertNull(ws.getSocket()); + } + + @Test(expected = IllegalArgumentException.class) + public void constructorRejectsNullHost() throws URISyntaxException { + TestableWebSocket ws = new TestableWebSocket<>(null, options); + } + + @Test + public void connectTest() throws Exception { + when(socket.mockedSocket.connect()).thenAnswer(invocation -> null); + + socket.connect(); + + Assert.assertNotNull(socket.getSocket()); + + socket.connect(); + socket.connect(); + socket.connect(); + + verify(socket.mockedSocket, times(1)).connect(); + + Assert.assertEquals(ProtocolState.OPEN, socket.getState()); + Assert.assertEquals(1, socket.stateChangedCount); + Assert.assertEquals(ProtocolState.OPEN, socket.lastStateDispatched); + } + + @Test + public void disconnectTest() throws Exception { + when(socket.mockedSocket.connect()).thenAnswer(invocation -> null); + + socket.connect(); + + Assert.assertEquals(ProtocolState.OPEN, socket.getState()); + Assert.assertEquals(1, socket.stateChangedCount); + Assert.assertEquals(ProtocolState.OPEN, socket.lastStateDispatched); + + socket.disconnect(); + socket.disconnect(); + socket.disconnect(); + + verify( + socket.mockedSocket, + times(1) + ).disconnect(); + } + + @Test + public void disconnectWithoutEverConnecting() throws Exception { + Assert.assertEquals(ProtocolState.CLOSE, socket.getState()); + Assert.assertEquals(0, socket.stateChangedCount); + + socket.disconnect(); + + Assert.assertEquals(ProtocolState.CLOSE, socket.getState()); + Assert.assertEquals(0, socket.stateChangedCount); + } +} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java new file mode 100644 index 00000000..6c8e94b7 --- /dev/null +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java @@ -0,0 +1,51 @@ +package io.kuzzle.test; + +import io.kuzzle.runner.Kuzzle; +import io.kuzzle.sdk.CoreClasses.Task; +import io.kuzzle.sdk.Events.EventListener; +import io.kuzzle.sdk.Options.KuzzleOptions; +import io.kuzzle.sdk.Protocol.AbstractProtocol; +import io.kuzzle.sdk.Protocol.ProtocolState; +import io.kuzzle.sdk.CoreClasses.Responses.Response; + +import java.net.URISyntaxException; +import java.util.concurrent.ConcurrentHashMap; + +public class TestableKuzzle extends Kuzzle { + + public TestableKuzzle(AbstractProtocol networkProtocol) throws URISyntaxException, IllegalArgumentException { + super(networkProtocol); + } + + public TestableKuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { + super(networkProtocol, options); + } + + public void setTokenExpiredEventListener(EventListener eventListener) { + super.tokenExpiredEvent = eventListener; + } + + public EventListener getTokenExpiredEventListener() { + return super.tokenExpiredEvent; + } + + public void setUnhandledResponseEventListener(EventListener eventListener) { + super.unhandledResponseEvent = eventListener; + } + + public EventListener getUnhandledResponseEventListener() { + return super.unhandledResponseEvent; + } + + public void onStateChanged(ProtocolState state) { + super.onStateChanged(state); + } + + public void onResponseReceived(String payload) { + super.onResponseReceived(payload); + } + + public ConcurrentHashMap>> getRequests() { + return super.requests; + } +} From 293198d476a2eabe6262acc97418735d4a6a7235 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 2 Sep 2019 13:49:26 +0200 Subject: [PATCH 03/14] Fix tests being in the wrong place --- .../src/test/java/io/kuzzle/runner/CoreClasses/GObject.java | 0 .../src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java | 0 .../src/test/java/io/kuzzle/runner/Kuzzle.java | 0 .../src/test/java/io/kuzzle/runner/Protocol/WebSocket.java | 0 .../test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java | 0 .../java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java | 0 .../test/java/io/kuzzle/test/EventsTest/EventListenerTests.java | 0 .../java/io/kuzzle/test/EventsTest/TestableEventListener.java | 0 .../src/test/java/io/kuzzle/test/Helpers/DefaultTests.java | 0 .../src/test/java/io/kuzzle/test/KuzzleTests.java | 0 .../test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java | 0 .../src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java | 0 .../src/test/java/io/kuzzle/test/TestableKuzzle.java | 0 13 files changed, 0 insertions(+), 0 deletions(-) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/runner/Kuzzle.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/KuzzleTests.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java (100%) rename {kuzzle-sdk-java => kuzzle-sdk-base}/src/test/java/io/kuzzle/test/TestableKuzzle.java (100%) diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java similarity index 100% rename from kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java rename to kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java From 13a258a513a080b5e3e23c7996edbcd7c4bbe507 Mon Sep 17 00:00:00 2001 From: Alexandre Bouthinon Date: Mon, 2 Sep 2019 17:13:32 +0200 Subject: [PATCH 04/14] Add Travis Ci configuration skeleton --- .travis.yml | 180 ++++++++++++++++++++-------------------------------- 1 file changed, 68 insertions(+), 112 deletions(-) diff --git a/.travis.yml b/.travis.yml index 674ad6f2..297c60a1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,119 +1,75 @@ - -env: - global: - # BINTRAY_USER - - secure: "LxONQZ8tHhxTqgu+kqx9fMCubCfTQHZsy/3ibE+l72xG8sOAYfj4hB5k1p4kklnv3skeFQEiL6B++B2qRITOEAPRdD8FExkc+UF/TM1rY5aUtjIjoA3uH4n9hYjHirTO5qNKf4KxDr1Zbcn4ISGebJ0EYwE0SG/ptrd06wPp1G8AHshc8XaZgen6gDaik66OWpQkOkmGsRz2EPmIBVgo7L2LGK21DSxE4/PTo+ou0WYCyxyyWSKLTLt1xZpt9LOtk7IckrHl+Nenl6IbV/CjHb3+5vwdifyFQd+K6AVe32iTIVjdxj7rDhEHYD0EqKb79ey+u8p9HquLnGH03gcVBeFQu/qhhQStsiwrD/S9c8jwBjWOOUnVI4bEbqjqxFaRlPfVnRaAjQZLRKHdqxyTJCdC2Ls79LmkqSCyTxM7WBwwgu4Slf6RJSbKJb5naHYlwDuKPbeyHLAYrxgjEHC28bxQiTr5wwBWxE9BLxUcnkFAXzsy3qE74FQOIjvQbtrruLIOGwRGRYtzyfygGA3MfTHug6JwZGngqFf3k+kbznE8fZe7zxMwT63P6/54rR5fU/plLoTNFqdQsZGAfGOSYuHIEzWXOkWxffqsOwxPa1VxQTLD32O95oBcrcvmw4toC2NeFTe/+zZRMfGMbu7QIi0AL3qFpky3j12zcyA/M2I=" - # BINTRAY_KEY - - secure: "Iqn4ImAwFmQeoXXDb5JOsfcunSiSeLvdp4+AEsIeniMhpIk++ZJPDSxecC+NrvndTrxOXVqHEsFUfHnZYvPHMuvg9nhXvz/rmmyYH0hZqkKg2q2qM+Sz2UJBCvs6D1sJv3ZEVi8d6fVx5bbKXMzSE023XFBBK7l8nBsG5ObXBOzTzrus9UP+fk4FXif/QKJNcUSN7rLejUIxMCk36gMQYqYGiiqL3VE60aTpaUh7Vqj/8nCEPcO3K3gXTVybcGBcmsvinV5YEc+5s5ue8eX10ONY0oYF5GFd7aEsrKEFzT2d7MVq0a29cH1rWrxt6q7vXGZNKAdAQrDyRZUz9rMFtqH+2xOgagm22UiUYNlzrn2eDYRBd08X0y043gumdgmOq/CsyaI5bcUSKMr+rsZ2XIzBjefl8MU0xBhtKMO9g9WRfGBxjRbdg0ivRQoVGJbcUXTDl2WrLMgMjt8DT4nQP+PHdIV2FjZVNioqucqmEzfHIJt+hiw7EonGDnZ9uqkW6hm6b4JpGr5QF1yY6kKVCUQxLueUBAVdiZpULdevL7uYEUzdWIES2wTFE7LaWpHqnCOHYVpkIQpdole6+R0OhINhSHK0FW858xhZ2QGjtL1SSh5yzK4th6dpGKCiwMUSGSj5frpIeWPi+GqYoUQz+TvMGLGG2XGfihx74kQE0FA=" - - AWS_ACCESS_KEY_ID=AKIAIYAXFUAHXOWP2MJA - # AWS_SECRET_ACCESS_KEY - - secure: "dIcQzFpHKRf92cAiMA+SYsudtHWNcbYadVDb7zlJayWGUGy0i4CGwwOoOOrUcWgHxYhdN9XGwvFJTSswjHLRiHEyPFBwW8x/VfaCRS+jAcblMXyWNajvm0930S/3fRv5LA+4UKNmeXMuCGSf35ZqyEIEeuThkIomYvB/tBD1wcMpBUtQfmilLm3sUTaGUnFB651jBHshlYOZ8BAGLLmX1PAfT1wCrpVcrjq5kayNOIilJkwKGSr6q9C0p7+ULNZ4bHsATKLlYNs7Xcs+9a66p1EtKetP72DQsHrr8x3wB2Hhk3U425kmjIoE3gYnF7x3h3EpO5m0rGessbgdRF1SF7XK7Bsj4ukLb4HoktA8G7734ox4848RpH60aKUHRCsiebX7JKgJe1eEwU5BZK8+PFPGH6bI1YG1HQNqthzotTHFXu058uMHnyLv2PmDWWEYMM79fCyuRo8gJJ8GJhDgaGLgtizzEb6grcNW+QwunjA6nP4o7F9o+9b3lfGlsgL595V/CeWLNnHvENkSr67RN2NkDZm6q6EHbOk8AWtQc24mVawCwCbcJjp0sPkbQdCHUXSBNXjdwrvJLA3h94A2uVEmrV7mzMdfj+i9X3IS/HXRLeQk6Ivq2s/b1W6c7rBfz4zZUO7Uu5iYpVzT71yNFra13JkW3REFgHgETEvGkko=" - - -sudo: true - +--- +# ----------------- +# YAML Templates +# ----------------- + +# ------------------------ +# Jobs configuration +# ------------------------ jobs: include: - - stage: Tests - name: Dead link check - if: type = pull_request OR type = push AND branch =~ /^master|[0-9]+-(dev|stable)$/ OR type = cron - language: node_js - node_js: 10 - - before_script: - - npm run doc-prepare - - npm run --prefix doc/framework clone-repos - script: - - gem install typhoeus - - HYDRA_MAX_CONCURRENCY=20 npm run --prefix doc/framework dead-links - - - stage: Deployment Doc Dev - name: Deploy next-docs.kuzzle.io - if: type = push AND branch =~ .*-dev - language: node_js - node_js: 10 - env: - - NODE_ENV=production - - S3_BUCKET=docs-next.kuzzle.io - - CLOUDFRONT_DISTRIBUTION_ID=E2ZCCEK9GRB49U - - AWS_DEFAULT_REGION=us-west-2 - - addons: - apt: - packages: - - python - - python-pip - - install: - - pip install awscli --upgrade --user - - script: - - npm run doc-prepare - - npm run doc-build - - deploy: - provider: script - script: - - npm run doc-upload - skip_cleanup: true - - after_deploy: - - npm run doc-cloudfront - - - stage: Deployment Doc Prod - name: Deploy docs.kuzzle.io - if: type = push AND branch =~ /^master|[0-9]+-stable$/ - language: node_js - node_js: 10 - env: - - NODE_ENV=production - - S3_BUCKET=docs.kuzzle.io - - CLOUDFRONT_DISTRIBUTION_ID=E3D6RP0POLCJMM - - AWS_DEFAULT_REGION=us-west-2 - - addons: - apt: - packages: - - python - - python-pip - - install: - - pip install awscli --upgrade --user - - script: - - npm run doc-prepare - - npm run doc-build - - deploy: - provider: script - script: - - npm run doc-upload - skip_cleanup: true - - after_deploy: - - npm run doc-cloudfront - - - - stage: Deployment - name: Deploy to Bintray - if: branch = master AND tag IS present AND type != cron + # --------------------------------------- + # Unit Tests & Linters + # --------------------------------------- + - stage: Unit Tests & Linters + name: Unit Tests & ESLint + dist: trusty language: java - - jdk: - - openjdk8 - + jdk: oraclejdk8 + sudo: false + before_cache: + - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock + - rm -fr $HOME/.gradle/caches/*/plugin-resolution/ + cache: + directories: + - $HOME/.gradle/caches/ + - $HOME/.gradle/wrapper/ + install: + - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-base + - gradle assemble script: - bash gradlew test jacocoTestReport - - notifications: - email: false - + - gradle check after_success: - bash <(curl -s https://codecov.io/bash) - deploy: - provider: script - script: ./gradlew bintrayUpload - skip_cleanup: true - on: - condition: $TRAVIS_BRANCH = master + # --------------------------------------- + # Builds + # --------------------------------------- + - stage: Builds + name: Build SDK Java + language: java + jdk: oraclejdk8 + sudo: false + before_cache: + - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock + - rm -fr $HOME/.gradle/caches/*/plugin-resolution/ + cache: + directories: + - $HOME/.gradle/caches/ + - $HOME/.gradle/wrapper/ + install: + - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-base + - gradle assemble + - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-java + - gradle assemble + script: + - gradle build + +# ------------------------ +# Stages configuration +# ------------------------ +stages: + - name: Unit Tests + if: type =~ /(cron|push|pull_request)/ AND branch =~ /^master|[0-9]+-(dev|stable)$/ + - name: Builds + if: type =~ /(cron|push|pull_request)/ AND branch =~ /^master|[0-9]+-(dev|stable)$/ + +# --------------------------------------- +# Notifications +# --------------------------------------- +notifications: + slack: + rooms: + - secure: "ACjz4TJEYBEzmwVOYrCNnr4+jC0FaX+qh150QacYGIgaQYL+U3xLEQmWNlZ3oxaPPMDAk42m+diHolqNwh6qsOWaPSWRlGfLKhHLSzRI98bhF7HQ+3eLMYmx7y7SKwRzyRjus0jgxp0Kc2mq0nhKqv+7rarQtIgWlC1PLrzZ35CUbUlqYSoeYAlXoyDB1eZgYsvjt+eC5yCvGePsfKbupWC2/hIVl+qZ+9AhVmOfiMv7daFW29Vu300aoY+0IqwX7jHGcmHn/7QCRsx0IBy/SL24TzfSV9SUSnbjK4fTrcrhjYDEZdH1lpvDtvr50GgkrTjy1wPVz8XIyCZ7LZolylkx+nR1MWyvum20QRFub2Qhz/+rS+OFiQZ8H01BPuklLUTSQhBksfpGBck3d2yNLiTqGEVWYTnZ9mkCnMQ3BzJXEF04KLHG7wYn2rk6wjPghVmFQH5GMsxM5v33CFgcNzp6lRJOX9CmjZosck6o9SA0WlazHH/CLWWKk1wrQ1ygDayW5m+N/o58UIxgW2LIUlp4tV1z/bRtO2yTd020yWchlKPVmf1A5OMfigJNMRsQGNZNadS7qA2M394OJw3/Hg+0EVF8gai/V8FRijmkxmhYyCIYMcjaGwx8JxfoMrRKcM76haBAhg0JQxsSVKzyXfONGzd5DXjcxSGZ2wuEdu0=" + on_success: never + on_failure: always From c6248f30b8cb963b0133b14108dfa70a655a1f13 Mon Sep 17 00:00:00 2001 From: ycombes Date: Tue, 3 Sep 2019 10:45:50 +0200 Subject: [PATCH 05/14] remove println --- kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java index c0d7c157..724ca998 100644 --- a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java +++ b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java @@ -136,8 +136,6 @@ public void disconnect() { * @param payload Raw API Response */ protected void onResponseReceived(String payload) { - - System.out.println(payload); Response response = new Response<>(); response.fromIJObject(IJObjectHelper.parse(payload)); From 51f8592e52c859e9704d1cf79c816d973d5a5fc4 Mon Sep 17 00:00:00 2001 From: ycombes Date: Wed, 11 Sep 2019 10:00:01 +0200 Subject: [PATCH 06/14] Improve IJObject --- .gitignore | 1 + kuzzle-sdk-android/.classpath | 6 + kuzzle-sdk-android/.project | 23 + .../org.eclipse.buildship.core.prefs | 13 + .../.settings/org.eclipse.jdt.core.prefs | 4 + kuzzle-sdk-base/.classpath | 30 ++ kuzzle-sdk-base/.project | 23 + .../org.eclipse.buildship.core.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 4 + .../java/io/kuzzle/sdk/AbstractKuzzle.java | 6 +- .../kuzzle/sdk/CoreClasses/Json/IJObject.java | 91 +++- .../sdk/CoreClasses/Responses/Response.java | 8 +- .../io/kuzzle/runner/CoreClasses/GObject.java | 471 ++++++++++++++--- kuzzle-sdk-java/.classpath | 24 + kuzzle-sdk-java/.project | 23 + .../org.eclipse.buildship.core.prefs | 2 + .../kuzzle/sdk_java/CoreClasses/GObject.java | 480 ++++++++++++++---- 17 files changed, 1012 insertions(+), 199 deletions(-) create mode 100644 kuzzle-sdk-android/.classpath create mode 100644 kuzzle-sdk-android/.project create mode 100644 kuzzle-sdk-android/.settings/org.eclipse.buildship.core.prefs create mode 100644 kuzzle-sdk-android/.settings/org.eclipse.jdt.core.prefs create mode 100644 kuzzle-sdk-base/.classpath create mode 100644 kuzzle-sdk-base/.project create mode 100644 kuzzle-sdk-base/.settings/org.eclipse.buildship.core.prefs create mode 100644 kuzzle-sdk-base/.settings/org.eclipse.jdt.core.prefs create mode 100644 kuzzle-sdk-java/.classpath create mode 100644 kuzzle-sdk-java/.project create mode 100644 kuzzle-sdk-java/.settings/org.eclipse.buildship.core.prefs diff --git a/.gitignore b/.gitignore index f3be9197..278a3ec2 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,6 @@ build out .idea *.iml +*.class doc/framework \ No newline at end of file diff --git a/kuzzle-sdk-android/.classpath b/kuzzle-sdk-android/.classpath new file mode 100644 index 00000000..eb19361b --- /dev/null +++ b/kuzzle-sdk-android/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/kuzzle-sdk-android/.project b/kuzzle-sdk-android/.project new file mode 100644 index 00000000..ffaa0fcf --- /dev/null +++ b/kuzzle-sdk-android/.project @@ -0,0 +1,23 @@ + + + kuzzle-sdk-android + Project kuzzle-sdk-android created by Buildship. + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.buildship.core.gradleprojectnature + + diff --git a/kuzzle-sdk-android/.settings/org.eclipse.buildship.core.prefs b/kuzzle-sdk-android/.settings/org.eclipse.buildship.core.prefs new file mode 100644 index 00000000..7338097b --- /dev/null +++ b/kuzzle-sdk-android/.settings/org.eclipse.buildship.core.prefs @@ -0,0 +1,13 @@ +arguments= +auto.sync=false +build.scans.enabled=false +connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(5.4)) +connection.project.dir= +eclipse.preferences.version=1 +gradle.user.home= +java.home= +jvm.arguments= +offline.mode=false +override.workspace.settings=true +show.console.view=true +show.executions.view=true diff --git a/kuzzle-sdk-android/.settings/org.eclipse.jdt.core.prefs b/kuzzle-sdk-android/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..35068d95 --- /dev/null +++ b/kuzzle-sdk-android/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,4 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/kuzzle-sdk-base/.classpath b/kuzzle-sdk-base/.classpath new file mode 100644 index 00000000..540156aa --- /dev/null +++ b/kuzzle-sdk-base/.classpath @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/kuzzle-sdk-base/.project b/kuzzle-sdk-base/.project new file mode 100644 index 00000000..824da072 --- /dev/null +++ b/kuzzle-sdk-base/.project @@ -0,0 +1,23 @@ + + + kuzzle-sdk-base + Project kuzzle-sdk-base created by Buildship. + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.buildship.core.gradleprojectnature + + diff --git a/kuzzle-sdk-base/.settings/org.eclipse.buildship.core.prefs b/kuzzle-sdk-base/.settings/org.eclipse.buildship.core.prefs new file mode 100644 index 00000000..e8895216 --- /dev/null +++ b/kuzzle-sdk-base/.settings/org.eclipse.buildship.core.prefs @@ -0,0 +1,2 @@ +connection.project.dir= +eclipse.preferences.version=1 diff --git a/kuzzle-sdk-base/.settings/org.eclipse.jdt.core.prefs b/kuzzle-sdk-base/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..35068d95 --- /dev/null +++ b/kuzzle-sdk-base/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,4 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java index 724ca998..e7086f01 100644 --- a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java +++ b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/AbstractKuzzle.java @@ -258,14 +258,14 @@ public CompletableFuture> query(T query) || queryJObject.isNull("volatile") ) { queryJObject.put("volatile", IJObjectHelper.newIJObject()); - } else if (!queryJObject.isIJObject("volatile")) { + } else if (!queryJObject.isJsonObject("volatile")) { throw new InternalException("Volatile data must be a JsonObject", 400); } - queryJObject.getIJObject("volatile") + queryJObject.getJsonObject("volatile") .put("sdkVersion", version); - queryJObject.getIJObject("volatile") + queryJObject.getJsonObject("volatile") .put("sdkInstanceId", instanceId); Task> task = new Task<>(); diff --git a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Json/IJObject.java b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Json/IJObject.java index d9038ace..11f2b903 100644 --- a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Json/IJObject.java +++ b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Json/IJObject.java @@ -5,20 +5,33 @@ */ public interface IJObject { + enum Type { + BOOLEAN, + CHARACTER, + BYTE, + SHORT, + INTEGER, + LONG, + FLOAT, + DOUBLE, + STRING, + JSON, + } + /** * Associate an object to the specified property key. */ - public void put(String property, Byte value); - public void put(String property, Short value); - public void put(String property, Integer value); - public void put(String property, Long value); - public void put(String property, String value); - public void put(String property, Double value); - public void put(String property, Float value); - public void put(String property, Boolean value); - public void put(String property, Character value); - public void put(String property, IJObject value); - public void put(String property, Object value); + public IJObject put(String property, Byte value); + public IJObject put(String property, Short value); + public IJObject put(String property, Integer value); + public IJObject put(String property, Long value); + public IJObject put(String property, String value); + public IJObject put(String property, Double value); + public IJObject put(String property, Float value); + public IJObject put(String property, Boolean value); + public IJObject put(String property, Character value); + public IJObject put(String property, IJObject value); + public IJObject put(String property, Object value); /** * Return the object at the specified property key. @@ -33,9 +46,37 @@ public interface IJObject { public String getString(String property); public Boolean getBoolean(String property); public Character getCharacter(String property); - public IJObject getIJObject(String property); + public IJObject getAsIJObject(String property); + public IJObject getJsonObject(String property); public Object get(String property); + /** + * Convert the IJObject to the specified object. + */ + public Byte toByte(); + public Short toShort(); + public Integer toInteger(); + public Long toLong(); + public Double toDouble(); + public Float toFloat(); + public String toString(); + public Boolean toBoolean(); + public Character toCharacter(); + + /** + * Convert the IJObject to the specified object. + */ + public boolean isByte(); + public boolean isShort(); + public boolean isInteger(); + public boolean isLong(); + public boolean isDouble(); + public boolean isFloat(); + public boolean isString(); + public boolean isBoolean(); + public boolean isCharacter(); + public boolean isJsonObject(); + /** * Return the object at the specified property key. * If null, return the specified default value. @@ -75,14 +116,7 @@ public interface IJObject { * @param property Property name. * @return If the property is an IJObject. */ - public boolean isIJObject(String property); - - /** Check if the property is a JsonArray. - * @param property Property name. - * @return If the property is an JsonArray. - */ - public boolean isJsonArray(String property); - + public boolean isJsonObject(String property); /** Convert an IJObject to String. * @return A Json String that represent the IJObject. @@ -104,16 +138,23 @@ public interface IJObject { * @return A new instance of IJObject. */ public IJObject newIJObject(); - - /** Create a new instance of IJObject from a Json Object of the specified json library - * @param json A Json Object of the specified json library. - * @return A new instance of IJObject. - */ public IJObject newIJObject(T json); + public IJObject newIJObject(Byte obj); + public IJObject newIJObject(Short obj); + public IJObject newIJObject(Integer obj); + public IJObject newIJObject(Long obj); + public IJObject newIJObject(Float obj); + public IJObject newIJObject(Double obj); + public IJObject newIJObject(Boolean obj); + public IJObject newIJObject(Character obj); + public IJObject newIJObject(String obj); + /** Parse a Json String and create a new instance of IJObject. * @param jsonString A Json String. * @return A new instance of IJObject created from the Json String. */ public IJObject parse(String jsonString); + + public Type getType(); } diff --git a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Responses/Response.java b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Responses/Response.java index 517ed420..c0e24400 100644 --- a/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Responses/Response.java +++ b/kuzzle-sdk-base/src/main/java/io/kuzzle/sdk/CoreClasses/Responses/Response.java @@ -15,7 +15,7 @@ public class Response implements JsonSerializable { /** * Response payload (depends on the executed API action) */ - public IJObject result; + public IJObject result; /** * Error object (null if the request finished successfully) @@ -55,7 +55,7 @@ public class Response implements JsonSerializable { /** * Volatile data. */ - public IJObject Volatile; + public IJObject Volatile; // The following properties are specific to real-time notifications @@ -92,9 +92,9 @@ public void fromIJObject(IJObject jsonObject) { IJObjectHelper.newIJObject() ); error = null; - if (jsonObject.isIJObject("error")) { + if (jsonObject.isJsonObject("error")) { error = new ErrorResponse(); - error.fromIJObject(jsonObject.getIJObject("error")); + error.fromIJObject(jsonObject.getJsonObject("error")); } requestId = jsonObject.getString("requestId"); status = jsonObject.optInteger("status", 0); diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java index 0dd30478..41d0e253 100644 --- a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java +++ b/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java @@ -9,281 +9,538 @@ public class GObject implements IJObject { - private JsonObject jsonObject; + private Object object; + private Type type; public GObject() { - this.jsonObject = new JsonObject(); + this.object = new JsonObject(); + type = Type.JSON; } - public GObject(JsonObject jsonObject) { - this.jsonObject = jsonObject; + public GObject(JsonObject object) { + this.object = object; + type = Type.JSON; } - @Override - public void put(String property, Byte value) { - jsonObject.addProperty(property, value); + public GObject(Character object) { + this.object = object; + type = Type.CHARACTER; + } + + public GObject(Boolean object) { + this.object = object; + type = Type.BOOLEAN; + } + + public GObject(Byte object) { + this.object = object; + type = Type.BYTE; + } + + public GObject(Short object) { + this.object = object; + type = Type.SHORT; + } + + public GObject(Integer object) { + this.object = object; + type = Type.INTEGER; + } + + public GObject(Long object) { + this.object = object; + type = Type.LONG; + } + + public GObject(Float object) { + this.object = object; + type = Type.FLOAT; + } + + public GObject(Double object) { + this.object = object; + type = Type.DOUBLE; + } + + public GObject(String object) { + this.object = object; + type = Type.STRING; } @Override - public void put(String property, Short value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Byte value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Integer value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Short value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Long value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Integer value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, String value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Long value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Double value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, String value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Float value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Double value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Boolean value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Float value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Character value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Boolean value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, IJObject value) { - if (value != null) { - jsonObject.add( - property, - new JsonParser().parse(value.toJsonString()) - ); - } else { - jsonObject.add(property, new JsonNull()); + public IJObject put(String property, Character value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; + } + + @Override + public IJObject put(String property, IJObject value) { + if (isJsonObject()) { + if (value != null) { + JsonObject json = ((JsonObject) object); + + switch (value.getType()) { + case BYTE: + json.addProperty(property, value.toByte()); + break; + case SHORT: + json.addProperty(property, value.toShort()); + break; + case INTEGER: + json.addProperty(property, value.toInteger()); + break; + case LONG: + json.addProperty(property, value.toLong()); + break; + case FLOAT: + json.addProperty(property, value.toFloat()); + break; + case DOUBLE: + json.addProperty(property, value.toDouble()); + break; + case STRING: + json.addProperty(property, value.toString()); + break; + case BOOLEAN: + json.addProperty(property, value.toBoolean()); + break; + case CHARACTER: + json.addProperty(property, value.toCharacter()); + break; + case JSON: + json.add(property, + new JsonParser().parse(value.toJsonString()) + ); + break; + default: break; + } + + } else { + ((JsonObject) object).add(property, new JsonNull()); + } } + return this; } @Override - public void put(String property, Object value) { - if (value == null) { - jsonObject.add(property, new JsonNull()); - } else if (value instanceof JsonElement) { - jsonObject.add(property, (JsonElement)value); - } else if (value instanceof JsonSerializable) { - put(property, ((JsonSerializable) value).toIJObject()); + public IJObject put(String property, Object value) { + if (isJsonObject()) { + if (value == null) { + ((JsonObject) object).add(property, new JsonNull()); + } else if (value instanceof JsonElement) { + ((JsonObject) object).add(property, (JsonElement) value); + } else if (value instanceof JsonSerializable) { + put(property, ((JsonSerializable) value).toIJObject()); + } } + return this; } @Override public Byte getByte(String property) { - return jsonObject.has(property) - ? jsonObject.get(property).getAsByte() + return !isNull(property) + ? ((JsonObject) object).get(property).getAsByte() : null; } @Override public Short getShort(String property) { return !isNull(property) - ? jsonObject.get(property).getAsShort() + ? ((JsonObject) object).get(property).getAsShort() : null; } @Override public Integer getInteger(String property) { return !isNull(property) - ? jsonObject.get(property).getAsInt() + ? ((JsonObject) object).get(property).getAsInt() : null; } @Override public Long getLong(String property) { return !isNull(property) - ? jsonObject.get(property).getAsLong() + ? ((JsonObject) object).get(property).getAsLong() : null; } @Override public Double getDouble(String property) { return !isNull(property) - ? jsonObject.get(property).getAsDouble() + ? ((JsonObject) object).get(property).getAsDouble() : null; } @Override public Float getFloat(String property) { return !isNull(property) - ? jsonObject.get(property).getAsFloat() + ? ((JsonObject) object).get(property).getAsFloat() : null; } @Override public String getString(String property) { return !isNull(property) - ? jsonObject.get(property).getAsString() + ? ((JsonObject) object).get(property).getAsString() : null; } @Override public Boolean getBoolean(String property) { return !isNull(property) - ? jsonObject.get(property).getAsBoolean() + ? ((JsonObject) object).get(property).getAsBoolean() : null; } @Override public Character getCharacter(String property) { return !isNull(property) - ? jsonObject.get(property).getAsCharacter() + ? ((JsonObject) object).get(property).getAsCharacter() : null; } @Override - public IJObject getIJObject(String property) { - return !isNull(property) - && jsonObject.get(property).isJsonObject() - ? new GObject(jsonObject.getAsJsonObject(property)) - : null; + public IJObject getAsIJObject(String property) { + if (isNull(property)) return null; + + if (getBoolean(property) != null) { + return new GObject(getBoolean(property)); + } else if (getCharacter(property) != null) { + return new GObject(getCharacter(property)); + } else if (getByte(property) != null) { + return new GObject(getByte(property)); + } else if (getShort(property) != null) { + return new GObject(getShort(property)); + } else if (getInteger(property) != null) { + return new GObject(getInteger(property)); + } else if (getLong(property) != null) { + return new GObject(getLong(property)); + } else if (getFloat(property) != null) { + return new GObject(getFloat(property)); + } else if (getDouble(property) != null) { + return new GObject(getDouble(property)); + } else if (getString(property) != null) { + return new GObject(getString(property)); + } else if (isJsonObject(property)) { + return new GObject(((JsonObject) object).getAsJsonObject(property)); + } + return null; + } + + @Override + public IJObject getJsonObject(String property) { + if (!isNull(property) + && ((JsonObject) object).get(property).isJsonObject() + ) { + return new GObject( + ((JsonObject) object).getAsJsonObject(property) + ); + } + return null; } @Override public Object get(String property) { return !isNull(property) - ? jsonObject.get(property) + ? ((JsonObject) object).get(property) : null; } + @Override + public String toString() { + if (!isString()) return null; + return (String)object; + } + + @Override + public Byte toByte() { + if (!isByte()) return null; + return (Byte)object; + } + + @Override + public Short toShort() { + if (!isShort()) return null; + return (Short) object; + } + + @Override + public Integer toInteger() { + if (!isInteger()) return null; + return (Integer) object; + } + + @Override + public Long toLong() { + if (!isLong()) return null; + return (Long) object; + } + + @Override + public Double toDouble() { + if (!isDouble()) return null; + return (Double) object; + } + + @Override + public Float toFloat() { + if (!isFloat()) return null; + return (Float) object; + } + + @Override + public Boolean toBoolean() { + if (!isBoolean()) return null; + return (Boolean) object; + } + + @Override + public Character toCharacter() { + if (!isCharacter()) return null; + return (Character) object; + } + + @Override + public boolean isByte() { + return type == Type.BYTE; + } + + @Override + public boolean isShort() { + return type == Type.SHORT; + } + + @Override + public boolean isInteger() { + return type == Type.INTEGER; + } + + @Override + public boolean isLong() { + return type == Type.LONG; + } + + @Override + public boolean isDouble() { + return type == Type.DOUBLE; + } + + @Override + public boolean isFloat() { + return type == Type.FLOAT; + } + + @Override + public boolean isString() { + return type == Type.STRING; + } + + @Override + public boolean isBoolean() { + return type == Type.BOOLEAN; + } + + @Override + public boolean isCharacter() { + return type == Type.CHARACTER; + } + + @Override + public boolean isJsonObject() { + return type == Type.JSON; + } + @Override public byte optByte(String property, byte defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsByte() + ? ((JsonObject) object).get(property).getAsByte() : defaultValue; } @Override public short optShort(String property, short defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsShort() + ? ((JsonObject) object).get(property).getAsShort() : defaultValue; } @Override public int optInteger(String property, int defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsInt() + ? ((JsonObject) object).get(property).getAsInt() : defaultValue; } @Override public long optLong(String property, long defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsLong() + ? ((JsonObject) object).get(property).getAsLong() : defaultValue; } @Override public double optDouble(String property, double defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsDouble() + ? ((JsonObject) object).get(property).getAsDouble() : defaultValue; } @Override public float optFloat(String property, float defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsFloat() + ? ((JsonObject) object).get(property).getAsFloat() : defaultValue; } @Override public String optString(String property, String defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsString() + ? ((JsonObject) object).get(property).getAsString() : defaultValue; } @Override public boolean optBoolean(String property, boolean defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsBoolean() + ? ((JsonObject) object).get(property).getAsBoolean() : defaultValue; } @Override public char optCharacter(String property, char defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsCharacter() + ? ((JsonObject) object).get(property).getAsCharacter() : defaultValue; } @Override public IJObject optIJObject(String property, IJObject defaultValue) { - return !isNull(property) - && jsonObject.get(property).isJsonObject() - ? new GObject(jsonObject.getAsJsonObject(property)) - : defaultValue; + IJObject obj; + if ( (obj = getAsIJObject(property)) != null) + return obj; + return defaultValue; } @Override public Object opt(String property, Object defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsByte() + ? ((JsonObject) object).get(property).getAsByte() : defaultValue; } @Override public boolean has(String property) { - return jsonObject.has(property); + if (!isJsonObject()) return false; + + return ((JsonObject) object).has(property); } @Override public Object remove(String property) { - return null; + if (!isJsonObject()) return null; + + return ((JsonObject) object).remove(property); } @Override public boolean isNull(String property) { - return !jsonObject.has(property) - || jsonObject.get(property).isJsonNull(); - } + if (!isJsonObject()) return true; - @Override - public boolean isIJObject(String property) { - return !isNull(property) - && jsonObject.get(property).isJsonObject(); + return !((JsonObject) object).has(property) + || ((JsonObject) object).get(property).isJsonNull(); } @Override - public boolean isJsonArray(String property) { + public boolean isJsonObject(String property) { return !isNull(property) - && jsonObject.get(property).isJsonArray(); + && ((JsonObject) object).get(property).isJsonObject(); } @Override public String toJsonString() { - return jsonObject.toString(); + if (!isJsonObject()) return null; + + return object.toString(); } @Override public int size() { - return jsonObject.size(); + if (!isJsonObject()) return 0; + + return ((JsonObject) object).size(); } @Override public JsonObject toNative() { - return jsonObject; + if (!isJsonObject()) return null; + + return (JsonObject)object; } @Override @@ -296,6 +553,51 @@ public IJObject newIJObject(JsonObject json) { return new GObject(json); } + @Override + public IJObject newIJObject(Byte obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Short obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Integer obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Long obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Float obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Double obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Boolean obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Character obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(String obj) { + return new GObject(obj); + } + @Override public IJObject parse(String jsonString) { JsonElement json = new JsonParser().parse(jsonString); @@ -307,4 +609,9 @@ public IJObject parse(String jsonString) { } return new GObject(); } + + @Override + public Type getType() { + return type; + } } diff --git a/kuzzle-sdk-java/.classpath b/kuzzle-sdk-java/.classpath new file mode 100644 index 00000000..13c7f5e5 --- /dev/null +++ b/kuzzle-sdk-java/.classpath @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/kuzzle-sdk-java/.project b/kuzzle-sdk-java/.project new file mode 100644 index 00000000..1a097e23 --- /dev/null +++ b/kuzzle-sdk-java/.project @@ -0,0 +1,23 @@ + + + kuzzle-sdk-java + Project kuzzle-sdk-java created by Buildship. + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.buildship.core.gradleprojectnature + + diff --git a/kuzzle-sdk-java/.settings/org.eclipse.buildship.core.prefs b/kuzzle-sdk-java/.settings/org.eclipse.buildship.core.prefs new file mode 100644 index 00000000..e8895216 --- /dev/null +++ b/kuzzle-sdk-java/.settings/org.eclipse.buildship.core.prefs @@ -0,0 +1,2 @@ +connection.project.dir= +eclipse.preferences.version=1 diff --git a/kuzzle-sdk-java/src/main/java/io/kuzzle/sdk_java/CoreClasses/GObject.java b/kuzzle-sdk-java/src/main/java/io/kuzzle/sdk_java/CoreClasses/GObject.java index c8a14ac5..b5559171 100644 --- a/kuzzle-sdk-java/src/main/java/io/kuzzle/sdk_java/CoreClasses/GObject.java +++ b/kuzzle-sdk-java/src/main/java/io/kuzzle/sdk_java/CoreClasses/GObject.java @@ -1,286 +1,546 @@ package io.kuzzle.sdk_java.CoreClasses; -import com.google.gson.*; +import com.google.gson.JsonElement; +import com.google.gson.JsonNull; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; import io.kuzzle.sdk.CoreClasses.Json.IJObject; import io.kuzzle.sdk.CoreClasses.Json.JsonSerializable; public class GObject implements IJObject { - private JsonObject jsonObject; + private Object object; + private Type type; public GObject() { - this.jsonObject = new JsonObject(); + this.object = new JsonObject(); + type = Type.JSON; } - public GObject(JsonObject jsonObject) { - this.jsonObject = jsonObject; + public GObject(JsonObject object) { + this.object = object; + type = Type.JSON; } - @Override - public void put(String property, Byte value) { - jsonObject.addProperty(property, value); + public GObject(Character object) { + this.object = object; + type = Type.CHARACTER; + } + + public GObject(Boolean object) { + this.object = object; + type = Type.BOOLEAN; + } + + public GObject(Byte object) { + this.object = object; + type = Type.BYTE; + } + + public GObject(Short object) { + this.object = object; + type = Type.SHORT; + } + + public GObject(Integer object) { + this.object = object; + type = Type.INTEGER; + } + + public GObject(Long object) { + this.object = object; + type = Type.LONG; + } + + public GObject(Float object) { + this.object = object; + type = Type.FLOAT; + } + + public GObject(Double object) { + this.object = object; + type = Type.DOUBLE; + } + + public GObject(String object) { + this.object = object; + type = Type.STRING; } @Override - public void put(String property, Short value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Byte value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Integer value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Short value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Long value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Integer value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, String value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Long value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Double value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, String value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Float value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Double value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Boolean value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Float value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, Character value) { - jsonObject.addProperty(property, value); + public IJObject put(String property, Boolean value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; } @Override - public void put(String property, IJObject value) { - if (value != null) { - jsonObject.add( - property, - new JsonParser().parse(value.toJsonString()) - ); - } else { - jsonObject.add(property, new JsonNull()); + public IJObject put(String property, Character value) { + if (isJsonObject()) { + ((JsonObject)object).addProperty(property, value); + } + return this; + } + + @Override + public IJObject put(String property, IJObject value) { + if (isJsonObject()) { + if (value != null) { + JsonObject json = ((JsonObject) object); + + switch (value.getType()) { + case BYTE: + json.addProperty(property, value.toByte()); + break; + case SHORT: + json.addProperty(property, value.toShort()); + break; + case INTEGER: + json.addProperty(property, value.toInteger()); + break; + case LONG: + json.addProperty(property, value.toLong()); + break; + case FLOAT: + json.addProperty(property, value.toFloat()); + break; + case DOUBLE: + json.addProperty(property, value.toDouble()); + break; + case STRING: + json.addProperty(property, value.toString()); + break; + case BOOLEAN: + json.addProperty(property, value.toBoolean()); + break; + case CHARACTER: + json.addProperty(property, value.toCharacter()); + break; + case JSON: + json.add(property, + new JsonParser().parse(value.toJsonString()) + ); + break; + default: break; + } + + } else { + ((JsonObject) object).add(property, new JsonNull()); + } } + return this; } @Override - public void put(String property, Object value) { - if (value == null) { - jsonObject.add(property, new JsonNull()); - } else if (value instanceof JsonElement) { - jsonObject.add(property, (JsonElement)value); - } else if (value instanceof JsonSerializable) { - put(property, ((JsonSerializable) value).toIJObject()); + public IJObject put(String property, Object value) { + if (isJsonObject()) { + if (value == null) { + ((JsonObject) object).add(property, new JsonNull()); + } else if (value instanceof JsonElement) { + ((JsonObject) object).add(property, (JsonElement) value); + } else if (value instanceof JsonSerializable) { + put(property, ((JsonSerializable) value).toIJObject()); + } } + return this; } @Override public Byte getByte(String property) { - return jsonObject.has(property) - ? jsonObject.get(property).getAsByte() + return !isNull(property) + ? ((JsonObject) object).get(property).getAsByte() : null; } @Override public Short getShort(String property) { return !isNull(property) - ? jsonObject.get(property).getAsShort() + ? ((JsonObject) object).get(property).getAsShort() : null; } @Override public Integer getInteger(String property) { return !isNull(property) - ? jsonObject.get(property).getAsInt() + ? ((JsonObject) object).get(property).getAsInt() : null; } @Override public Long getLong(String property) { return !isNull(property) - ? jsonObject.get(property).getAsLong() + ? ((JsonObject) object).get(property).getAsLong() : null; } @Override public Double getDouble(String property) { return !isNull(property) - ? jsonObject.get(property).getAsDouble() + ? ((JsonObject) object).get(property).getAsDouble() : null; } @Override public Float getFloat(String property) { return !isNull(property) - ? jsonObject.get(property).getAsFloat() + ? ((JsonObject) object).get(property).getAsFloat() : null; } @Override public String getString(String property) { return !isNull(property) - ? jsonObject.get(property).getAsString() + ? ((JsonObject) object).get(property).getAsString() : null; } @Override public Boolean getBoolean(String property) { return !isNull(property) - ? jsonObject.get(property).getAsBoolean() + ? ((JsonObject) object).get(property).getAsBoolean() : null; } @Override public Character getCharacter(String property) { return !isNull(property) - ? jsonObject.get(property).getAsCharacter() + ? ((JsonObject) object).get(property).getAsCharacter() : null; } @Override - public IJObject getIJObject(String property) { - return !isNull(property) - && jsonObject.get(property).isJsonObject() - ? new GObject(jsonObject.getAsJsonObject(property)) - : null; + public IJObject getAsIJObject(String property) { + if (isNull(property)) return null; + + if (getBoolean(property) != null) { + return new GObject(getBoolean(property)); + } else if (getCharacter(property) != null) { + return new GObject(getCharacter(property)); + } else if (getByte(property) != null) { + return new GObject(getByte(property)); + } else if (getShort(property) != null) { + return new GObject(getShort(property)); + } else if (getInteger(property) != null) { + return new GObject(getInteger(property)); + } else if (getLong(property) != null) { + return new GObject(getLong(property)); + } else if (getFloat(property) != null) { + return new GObject(getFloat(property)); + } else if (getDouble(property) != null) { + return new GObject(getDouble(property)); + } else if (getString(property) != null) { + return new GObject(getString(property)); + } else if (isJsonObject(property)) { + return new GObject(((JsonObject) object).getAsJsonObject(property)); + } + return null; + } + + @Override + public IJObject getJsonObject(String property) { + if (!isNull(property) + && ((JsonObject) object).get(property).isJsonObject() + ) { + return new GObject( + ((JsonObject) object).getAsJsonObject(property) + ); + } + return null; } @Override public Object get(String property) { return !isNull(property) - ? jsonObject.get(property) + ? ((JsonObject) object).get(property) : null; } + @Override + public String toString() { + if (!isString()) return null; + return (String)object; + } + + @Override + public Byte toByte() { + if (!isByte()) return null; + return (Byte)object; + } + + @Override + public Short toShort() { + if (!isShort()) return null; + return (Short) object; + } + + @Override + public Integer toInteger() { + if (!isInteger()) return null; + return (Integer) object; + } + + @Override + public Long toLong() { + if (!isLong()) return null; + return (Long) object; + } + + @Override + public Double toDouble() { + if (!isDouble()) return null; + return (Double) object; + } + + @Override + public Float toFloat() { + if (!isFloat()) return null; + return (Float) object; + } + + @Override + public Boolean toBoolean() { + if (!isBoolean()) return null; + return (Boolean) object; + } + + @Override + public Character toCharacter() { + if (!isCharacter()) return null; + return (Character) object; + } + + @Override + public boolean isByte() { + return type == Type.BYTE; + } + + @Override + public boolean isShort() { + return type == Type.SHORT; + } + + @Override + public boolean isInteger() { + return type == Type.INTEGER; + } + + @Override + public boolean isLong() { + return type == Type.LONG; + } + + @Override + public boolean isDouble() { + return type == Type.DOUBLE; + } + + @Override + public boolean isFloat() { + return type == Type.FLOAT; + } + + @Override + public boolean isString() { + return type == Type.STRING; + } + + @Override + public boolean isBoolean() { + return type == Type.BOOLEAN; + } + + @Override + public boolean isCharacter() { + return type == Type.CHARACTER; + } + + @Override + public boolean isJsonObject() { + return type == Type.JSON; + } + @Override public byte optByte(String property, byte defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsByte() + ? ((JsonObject) object).get(property).getAsByte() : defaultValue; } @Override public short optShort(String property, short defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsShort() + ? ((JsonObject) object).get(property).getAsShort() : defaultValue; } @Override public int optInteger(String property, int defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsInt() + ? ((JsonObject) object).get(property).getAsInt() : defaultValue; } @Override public long optLong(String property, long defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsLong() + ? ((JsonObject) object).get(property).getAsLong() : defaultValue; } @Override public double optDouble(String property, double defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsDouble() + ? ((JsonObject) object).get(property).getAsDouble() : defaultValue; } @Override public float optFloat(String property, float defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsFloat() + ? ((JsonObject) object).get(property).getAsFloat() : defaultValue; } @Override public String optString(String property, String defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsString() + ? ((JsonObject) object).get(property).getAsString() : defaultValue; } @Override public boolean optBoolean(String property, boolean defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsBoolean() + ? ((JsonObject) object).get(property).getAsBoolean() : defaultValue; } @Override public char optCharacter(String property, char defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsCharacter() + ? ((JsonObject) object).get(property).getAsCharacter() : defaultValue; } @Override public IJObject optIJObject(String property, IJObject defaultValue) { - return !isNull(property) - && jsonObject.get(property).isJsonObject() - ? new GObject(jsonObject.getAsJsonObject(property)) - : defaultValue; + IJObject obj; + if ( (obj = getAsIJObject(property)) != null) + return obj; + return defaultValue; } @Override public Object opt(String property, Object defaultValue) { return !isNull(property) - ? jsonObject.get(property).getAsByte() + ? ((JsonObject) object).get(property).getAsByte() : defaultValue; } @Override public boolean has(String property) { - return jsonObject.has(property); + if (!isJsonObject()) return false; + + return ((JsonObject) object).has(property); } @Override public Object remove(String property) { - return null; + if (!isJsonObject()) return null; + + return ((JsonObject) object).remove(property); } @Override public boolean isNull(String property) { - return !jsonObject.has(property) - || jsonObject.get(property).isJsonNull(); - } + if (!isJsonObject()) return true; - @Override - public boolean isIJObject(String property) { - return !isNull(property) - && jsonObject.get(property).isJsonObject(); + return !((JsonObject) object).has(property) + || ((JsonObject) object).get(property).isJsonNull(); } @Override - public boolean isJsonArray(String property) { + public boolean isJsonObject(String property) { return !isNull(property) - && jsonObject.get(property).isJsonArray(); + && ((JsonObject) object).get(property).isJsonObject(); } @Override public String toJsonString() { - return jsonObject.toString(); + if (!isJsonObject()) return null; + + return object.toString(); } @Override public int size() { - return jsonObject.size(); + if (!isJsonObject()) return 0; + + return ((JsonObject) object).size(); } @Override public JsonObject toNative() { - return jsonObject; + if (!isJsonObject()) return null; + + return (JsonObject)object; } @Override @@ -293,15 +553,65 @@ public IJObject newIJObject(JsonObject json) { return new GObject(json); } + @Override + public IJObject newIJObject(Byte obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Short obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Integer obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Long obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Float obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Double obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Boolean obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(Character obj) { + return new GObject(obj); + } + + @Override + public IJObject newIJObject(String obj) { + return new GObject(obj); + } + @Override public IJObject parse(String jsonString) { JsonElement json = new JsonParser().parse(jsonString); if (json != null - && !json.isJsonNull() - && json.isJsonObject() + && !json.isJsonNull() + && json.isJsonObject() ) { return new GObject(json.getAsJsonObject()); } return new GObject(); } + + @Override + public Type getType() { + return type; + } } From daaa8302c6ad725cdc8cacbffa79c1a317f9cd47 Mon Sep 17 00:00:00 2001 From: ycombes Date: Fri, 13 Sep 2019 16:32:25 +0200 Subject: [PATCH 07/14] move unit tests (not working for now) --- .../src/test/java/io/kuzzle/runner/CoreClasses/GObject.java | 0 .../src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java | 0 .../src/test/java/io/kuzzle/runner/Kuzzle.java | 0 .../src/test/java/io/kuzzle/runner/Protocol/WebSocket.java | 0 .../test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java | 0 .../java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java | 0 .../test/java/io/kuzzle/test/EventsTest/EventListenerTests.java | 0 .../java/io/kuzzle/test/EventsTest/TestableEventListener.java | 0 .../src/test/java/io/kuzzle/test/Helpers/DefaultTests.java | 0 .../src/test/java/io/kuzzle/test/KuzzleTests.java | 0 .../test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java | 0 .../src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java | 0 .../src/test/java/io/kuzzle/test/TestableKuzzle.java | 0 13 files changed, 0 insertions(+), 0 deletions(-) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/runner/Kuzzle.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/KuzzleTests.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java (100%) rename {kuzzle-sdk-base => kuzzle-sdk-java}/src/test/java/io/kuzzle/test/TestableKuzzle.java (100%) diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Kuzzle.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TaskTests.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/CoreClasses/TaskTest/TestableTask.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/EventListenerTests.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/EventsTest/TestableEventListener.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/Helpers/DefaultTests.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/KuzzleTests.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java diff --git a/kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java similarity index 100% rename from kuzzle-sdk-base/src/test/java/io/kuzzle/test/TestableKuzzle.java rename to kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java From fd29361ac8eb834218b028b53a2dc195bedfc328 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 11:47:41 +0200 Subject: [PATCH 08/14] Fix unit tests --- .../io/kuzzle/runner/CoreClasses/GObject.java | 617 ------------------ .../kuzzle/runner/Helpers/IJObjectHelper.java | 22 - .../test/java/io/kuzzle/runner/Kuzzle.java | 20 - .../io/kuzzle/runner/Protocol/WebSocket.java | 19 - .../test/java/io/kuzzle/test/KuzzleTests.java | 45 +- .../test/ProtocolTest/TestableWebSocket.java | 6 +- .../test/ProtocolTest/WebSocketTests.java | 10 +- .../java/io/kuzzle/test/TestableKuzzle.java | 12 +- 8 files changed, 35 insertions(+), 716 deletions(-) delete mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java delete mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java delete mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java delete mode 100644 kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java deleted file mode 100644 index 41d0e253..00000000 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/CoreClasses/GObject.java +++ /dev/null @@ -1,617 +0,0 @@ -package io.kuzzle.runner.CoreClasses; - -import com.google.gson.JsonElement; -import com.google.gson.JsonNull; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; -import io.kuzzle.sdk.CoreClasses.Json.IJObject; -import io.kuzzle.sdk.CoreClasses.Json.JsonSerializable; - -public class GObject implements IJObject { - - private Object object; - private Type type; - - public GObject() { - this.object = new JsonObject(); - type = Type.JSON; - } - - public GObject(JsonObject object) { - this.object = object; - type = Type.JSON; - } - - public GObject(Character object) { - this.object = object; - type = Type.CHARACTER; - } - - public GObject(Boolean object) { - this.object = object; - type = Type.BOOLEAN; - } - - public GObject(Byte object) { - this.object = object; - type = Type.BYTE; - } - - public GObject(Short object) { - this.object = object; - type = Type.SHORT; - } - - public GObject(Integer object) { - this.object = object; - type = Type.INTEGER; - } - - public GObject(Long object) { - this.object = object; - type = Type.LONG; - } - - public GObject(Float object) { - this.object = object; - type = Type.FLOAT; - } - - public GObject(Double object) { - this.object = object; - type = Type.DOUBLE; - } - - public GObject(String object) { - this.object = object; - type = Type.STRING; - } - - @Override - public IJObject put(String property, Byte value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Short value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Integer value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Long value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, String value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Double value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Float value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Boolean value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, Character value) { - if (isJsonObject()) { - ((JsonObject)object).addProperty(property, value); - } - return this; - } - - @Override - public IJObject put(String property, IJObject value) { - if (isJsonObject()) { - if (value != null) { - JsonObject json = ((JsonObject) object); - - switch (value.getType()) { - case BYTE: - json.addProperty(property, value.toByte()); - break; - case SHORT: - json.addProperty(property, value.toShort()); - break; - case INTEGER: - json.addProperty(property, value.toInteger()); - break; - case LONG: - json.addProperty(property, value.toLong()); - break; - case FLOAT: - json.addProperty(property, value.toFloat()); - break; - case DOUBLE: - json.addProperty(property, value.toDouble()); - break; - case STRING: - json.addProperty(property, value.toString()); - break; - case BOOLEAN: - json.addProperty(property, value.toBoolean()); - break; - case CHARACTER: - json.addProperty(property, value.toCharacter()); - break; - case JSON: - json.add(property, - new JsonParser().parse(value.toJsonString()) - ); - break; - default: break; - } - - } else { - ((JsonObject) object).add(property, new JsonNull()); - } - } - return this; - } - - @Override - public IJObject put(String property, Object value) { - if (isJsonObject()) { - if (value == null) { - ((JsonObject) object).add(property, new JsonNull()); - } else if (value instanceof JsonElement) { - ((JsonObject) object).add(property, (JsonElement) value); - } else if (value instanceof JsonSerializable) { - put(property, ((JsonSerializable) value).toIJObject()); - } - } - return this; - } - - @Override - public Byte getByte(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsByte() - : null; - } - - @Override - public Short getShort(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsShort() - : null; - } - - @Override - public Integer getInteger(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsInt() - : null; - } - - @Override - public Long getLong(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsLong() - : null; - } - - @Override - public Double getDouble(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsDouble() - : null; - } - - @Override - public Float getFloat(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsFloat() - : null; - } - - @Override - public String getString(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsString() - : null; - } - - @Override - public Boolean getBoolean(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsBoolean() - : null; - } - - @Override - public Character getCharacter(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsCharacter() - : null; - } - - @Override - public IJObject getAsIJObject(String property) { - if (isNull(property)) return null; - - if (getBoolean(property) != null) { - return new GObject(getBoolean(property)); - } else if (getCharacter(property) != null) { - return new GObject(getCharacter(property)); - } else if (getByte(property) != null) { - return new GObject(getByte(property)); - } else if (getShort(property) != null) { - return new GObject(getShort(property)); - } else if (getInteger(property) != null) { - return new GObject(getInteger(property)); - } else if (getLong(property) != null) { - return new GObject(getLong(property)); - } else if (getFloat(property) != null) { - return new GObject(getFloat(property)); - } else if (getDouble(property) != null) { - return new GObject(getDouble(property)); - } else if (getString(property) != null) { - return new GObject(getString(property)); - } else if (isJsonObject(property)) { - return new GObject(((JsonObject) object).getAsJsonObject(property)); - } - return null; - } - - @Override - public IJObject getJsonObject(String property) { - if (!isNull(property) - && ((JsonObject) object).get(property).isJsonObject() - ) { - return new GObject( - ((JsonObject) object).getAsJsonObject(property) - ); - } - return null; - } - - @Override - public Object get(String property) { - return !isNull(property) - ? ((JsonObject) object).get(property) - : null; - } - - @Override - public String toString() { - if (!isString()) return null; - return (String)object; - } - - @Override - public Byte toByte() { - if (!isByte()) return null; - return (Byte)object; - } - - @Override - public Short toShort() { - if (!isShort()) return null; - return (Short) object; - } - - @Override - public Integer toInteger() { - if (!isInteger()) return null; - return (Integer) object; - } - - @Override - public Long toLong() { - if (!isLong()) return null; - return (Long) object; - } - - @Override - public Double toDouble() { - if (!isDouble()) return null; - return (Double) object; - } - - @Override - public Float toFloat() { - if (!isFloat()) return null; - return (Float) object; - } - - @Override - public Boolean toBoolean() { - if (!isBoolean()) return null; - return (Boolean) object; - } - - @Override - public Character toCharacter() { - if (!isCharacter()) return null; - return (Character) object; - } - - @Override - public boolean isByte() { - return type == Type.BYTE; - } - - @Override - public boolean isShort() { - return type == Type.SHORT; - } - - @Override - public boolean isInteger() { - return type == Type.INTEGER; - } - - @Override - public boolean isLong() { - return type == Type.LONG; - } - - @Override - public boolean isDouble() { - return type == Type.DOUBLE; - } - - @Override - public boolean isFloat() { - return type == Type.FLOAT; - } - - @Override - public boolean isString() { - return type == Type.STRING; - } - - @Override - public boolean isBoolean() { - return type == Type.BOOLEAN; - } - - @Override - public boolean isCharacter() { - return type == Type.CHARACTER; - } - - @Override - public boolean isJsonObject() { - return type == Type.JSON; - } - - @Override - public byte optByte(String property, byte defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsByte() - : defaultValue; - } - - @Override - public short optShort(String property, short defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsShort() - : defaultValue; - } - - @Override - public int optInteger(String property, int defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsInt() - : defaultValue; - } - - @Override - public long optLong(String property, long defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsLong() - : defaultValue; - } - - @Override - public double optDouble(String property, double defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsDouble() - : defaultValue; - } - - @Override - public float optFloat(String property, float defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsFloat() - : defaultValue; - } - - @Override - public String optString(String property, String defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsString() - : defaultValue; - } - - @Override - public boolean optBoolean(String property, boolean defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsBoolean() - : defaultValue; - } - - @Override - public char optCharacter(String property, char defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsCharacter() - : defaultValue; - } - - @Override - public IJObject optIJObject(String property, IJObject defaultValue) { - IJObject obj; - if ( (obj = getAsIJObject(property)) != null) - return obj; - return defaultValue; - } - - @Override - public Object opt(String property, Object defaultValue) { - return !isNull(property) - ? ((JsonObject) object).get(property).getAsByte() - : defaultValue; - } - - @Override - public boolean has(String property) { - if (!isJsonObject()) return false; - - return ((JsonObject) object).has(property); - } - - @Override - public Object remove(String property) { - if (!isJsonObject()) return null; - - return ((JsonObject) object).remove(property); - } - - @Override - public boolean isNull(String property) { - if (!isJsonObject()) return true; - - return !((JsonObject) object).has(property) - || ((JsonObject) object).get(property).isJsonNull(); - } - - @Override - public boolean isJsonObject(String property) { - return !isNull(property) - && ((JsonObject) object).get(property).isJsonObject(); - } - - @Override - public String toJsonString() { - if (!isJsonObject()) return null; - - return object.toString(); - } - - @Override - public int size() { - if (!isJsonObject()) return 0; - - return ((JsonObject) object).size(); - } - - @Override - public JsonObject toNative() { - if (!isJsonObject()) return null; - - return (JsonObject)object; - } - - @Override - public IJObject newIJObject() { - return new GObject(); - } - - @Override - public IJObject newIJObject(JsonObject json) { - return new GObject(json); - } - - @Override - public IJObject newIJObject(Byte obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Short obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Integer obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Long obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Float obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Double obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Boolean obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(Character obj) { - return new GObject(obj); - } - - @Override - public IJObject newIJObject(String obj) { - return new GObject(obj); - } - - @Override - public IJObject parse(String jsonString) { - JsonElement json = new JsonParser().parse(jsonString); - if (json != null - && !json.isJsonNull() - && json.isJsonObject() - ) { - return new GObject(json.getAsJsonObject()); - } - return new GObject(); - } - - @Override - public Type getType() { - return type; - } -} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java deleted file mode 100644 index 956b99fd..00000000 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Helpers/IJObjectHelper.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.kuzzle.runner.Helpers; - -import io.kuzzle.runner.CoreClasses.GObject; -import io.kuzzle.sdk.CoreClasses.Json.IJObject; - -public class IJObjectHelper { - - private static IJObject jsonConstructor = new GObject(); - - public static IJObject newIJObject() { - return jsonConstructor.newIJObject(); - } - - public static IJObject newIJObject(T json) { - return jsonConstructor.newIJObject(json); - } - - public static IJObject parse(String json) { - return jsonConstructor.parse(json); - } - -} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java deleted file mode 100644 index 56d0fc06..00000000 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Kuzzle.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.kuzzle.runner; - -import io.kuzzle.runner.Helpers.IJObjectHelper; -import io.kuzzle.sdk.AbstractKuzzle; -import io.kuzzle.sdk.CoreClasses.Json.IJObject; -import io.kuzzle.sdk.Options.KuzzleOptions; -import io.kuzzle.sdk.Protocol.AbstractProtocol; - -import java.net.URISyntaxException; - -public class Kuzzle extends AbstractKuzzle { - public Kuzzle(AbstractProtocol networkProtocol) - throws IllegalArgumentException { - super((IJObject)IJObjectHelper.newIJObject(), networkProtocol); - } - - public Kuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { - super((IJObject) IJObjectHelper.newIJObject(), networkProtocol, options); - } -} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java deleted file mode 100644 index 0bede991..00000000 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/runner/Protocol/WebSocket.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.kuzzle.runner.Protocol; - -import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; -import io.kuzzle.sdk.Protocol.AbstractWebSocket; - -import java.net.URISyntaxException; - -public class WebSocket extends AbstractWebSocket { - - public WebSocket(String host) - throws URISyntaxException, IllegalArgumentException { - super(host); - } - - public WebSocket(String host, WebSocketOptions options) - throws URISyntaxException, IllegalArgumentException { - super(host, options); - } -} diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java index c950a218..decab2d6 100644 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/KuzzleTests.java @@ -1,8 +1,6 @@ package io.kuzzle.test; -import io.kuzzle.runner.Helpers.IJObjectHelper; -import io.kuzzle.runner.Protocol.WebSocket; -import io.kuzzle.sdk.CoreClasses.Json.IJObject; +import io.kuzzle.sdk.CoreClasses.Json.JsonSerializer; import io.kuzzle.sdk.CoreClasses.Task; import io.kuzzle.sdk.Events.EventListener; import io.kuzzle.sdk.Exceptions.InternalException; @@ -11,6 +9,7 @@ import io.kuzzle.sdk.Protocol.ProtocolState; import io.kuzzle.sdk.CoreClasses.Responses.ErrorResponse; import io.kuzzle.sdk.CoreClasses.Responses.Response; +import io.kuzzle.sdk.Protocol.WebSocket; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -23,13 +22,13 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicBoolean; -public class KuzzleTests { - private AbstractProtocol networkProtocol = Mockito.mock(WebSocket.class); +public class KuzzleTests { + private AbstractProtocol networkProtocol = Mockito.mock(WebSocket.class); private EventListener tokenExpiredEventListener = Mockito.mock(EventListener.class); - private EventListener> + private EventListener unhandledResponseEventListener = Mockito.mock(EventListener.class); - private TestableKuzzle kuzzle; + private TestableKuzzle kuzzle; @Before public void setup() throws URISyntaxException { @@ -76,10 +75,10 @@ public void unregisterTokenExpiredEvent() throws Exception { @Test public void onStateChanged() { - ConcurrentHashMap>> + ConcurrentHashMap> requests = kuzzle.getRequests(); - Task> response = new Task<>(); + Task response = new Task<>(); requests.put("foobar", response); kuzzle.onStateChanged(ProtocolState.CLOSE); Assert.assertEquals(0, requests.size()); @@ -94,7 +93,7 @@ public void queryShouldThrowWhenNotConnected() (Answer) invocation -> ProtocolState.CLOSE ); - kuzzle.query(IJObjectHelper.newIJObject().toNative()); + kuzzle.query(new ConcurrentHashMap<>()); } @Test @@ -104,48 +103,48 @@ public void querySuccess() throws NotConnectedException, InternalException { (Answer) invocation -> ProtocolState.OPEN ); - CompletableFuture> + CompletableFuture response = kuzzle.query( - IJObjectHelper.newIJObject().toNative() + new ConcurrentHashMap<>() ); Assert.assertNotNull(response); Mockito.verify( networkProtocol, Mockito.times(1) - ).send(Matchers.any(IJObject.class)); + ).send(Matchers.any(ConcurrentHashMap.class)); } @Test(expected = InternalException.class) - public void queryShouldThrowWhenVolatileIsNotIJObject() + public void queryShouldThrowWhenVolatileIsNotConcurrentHashMap() throws NotConnectedException, InternalException { Mockito.when(networkProtocol.getState()) .thenAnswer( (Answer) invocation -> ProtocolState.OPEN ); - IJObject payload = IJObjectHelper.newIJObject(); + ConcurrentHashMap payload = new ConcurrentHashMap<>(); payload.put("volatile", "foobar"); - kuzzle.query(payload.toNative()); + kuzzle.query(payload); } @Test public void onResponseReceivedAndTokenIsExpired() { - ConcurrentHashMap>> + ConcurrentHashMap> requests = kuzzle.getRequests(); - Response response = new Response(); + Response response = new Response(); response.error = new ErrorResponse(); response.error.message = "Token expired"; response.error.status = 42; response.room = "room-id"; - Task> task = new Task>(); + Task task = new Task<>(); requests.put("room-id", task); - kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + kuzzle.onResponseReceived(JsonSerializer.serialize(response.toMap())); Mockito.verify( tokenExpiredEventListener, @@ -155,18 +154,18 @@ public void onResponseReceivedAndTokenIsExpired() { @Test public void onResponseReceivedAndResponseIsUnhandled() { - ConcurrentHashMap>> + ConcurrentHashMap> requests = kuzzle.getRequests(); AtomicBoolean success = new AtomicBoolean(false); Response response = new Response(); response.requestId = "foobar"; - Task> task = new Task>(); + Task task = new Task<>(); requests.put("request-id", task); - kuzzle.onResponseReceived(response.toIJObject().toJsonString()); + kuzzle.onResponseReceived(JsonSerializer.serialize(response.toMap())); Mockito.verify( unhandledResponseEventListener, diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java index 0dd2e2dd..daae19df 100644 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/TestableWebSocket.java @@ -1,15 +1,13 @@ package io.kuzzle.test.ProtocolTest; -import io.kuzzle.runner.Protocol.WebSocket; import io.kuzzle.sdk.Options.Protocol.WebSocketOptions; import io.kuzzle.sdk.Protocol.ProtocolState; - -import java.io.IOException; +import io.kuzzle.sdk.Protocol.WebSocket; import java.net.URISyntaxException; import static org.mockito.Mockito.mock; -public class TestableWebSocket extends WebSocket { +public class TestableWebSocket extends WebSocket { public int stateChangedCount = 0; public ProtocolState lastStateDispatched = ProtocolState.CLOSE; public com.neovisionaries.ws.client.WebSocket diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java index 06ce7bbb..ed6e1252 100644 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/ProtocolTest/WebSocketTests.java @@ -10,9 +10,9 @@ import static org.mockito.Mockito.*; -public class WebSocketTests { +public class WebSocketTests { - private TestableWebSocket socket; + private TestableWebSocket socket; private String host; private WebSocketOptions options; @@ -22,12 +22,12 @@ public void setup() throws URISyntaxException { options = new WebSocketOptions() .withPort(1234) .withSsl(true); - socket = new TestableWebSocket<>(host, options); + socket = new TestableWebSocket(host, options); } @Test public void constructorNotConnected() throws URISyntaxException { - TestableWebSocket ws = new TestableWebSocket<>(host, options); + TestableWebSocket ws = new TestableWebSocket(host, options); Assert.assertEquals(ProtocolState.CLOSE, ws.getState()); Assert.assertNull(ws.getSocket()); @@ -35,7 +35,7 @@ public void constructorNotConnected() throws URISyntaxException { @Test(expected = IllegalArgumentException.class) public void constructorRejectsNullHost() throws URISyntaxException { - TestableWebSocket ws = new TestableWebSocket<>(null, options); + TestableWebSocket ws = new TestableWebSocket(null, options); } @Test diff --git a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java index 6c8e94b7..f42d8137 100644 --- a/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java +++ b/kuzzle-sdk-java/src/test/java/io/kuzzle/test/TestableKuzzle.java @@ -1,23 +1,23 @@ package io.kuzzle.test; -import io.kuzzle.runner.Kuzzle; +import io.kuzzle.sdk.CoreClasses.Responses.Response; import io.kuzzle.sdk.CoreClasses.Task; import io.kuzzle.sdk.Events.EventListener; +import io.kuzzle.sdk.Kuzzle; import io.kuzzle.sdk.Options.KuzzleOptions; import io.kuzzle.sdk.Protocol.AbstractProtocol; import io.kuzzle.sdk.Protocol.ProtocolState; -import io.kuzzle.sdk.CoreClasses.Responses.Response; import java.net.URISyntaxException; import java.util.concurrent.ConcurrentHashMap; -public class TestableKuzzle extends Kuzzle { +public class TestableKuzzle extends Kuzzle { - public TestableKuzzle(AbstractProtocol networkProtocol) throws URISyntaxException, IllegalArgumentException { + public TestableKuzzle(AbstractProtocol networkProtocol) throws URISyntaxException, IllegalArgumentException { super(networkProtocol); } - public TestableKuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { + public TestableKuzzle(AbstractProtocol networkProtocol, KuzzleOptions options) throws IllegalArgumentException { super(networkProtocol, options); } @@ -45,7 +45,7 @@ public void onResponseReceived(String payload) { super.onResponseReceived(payload); } - public ConcurrentHashMap>> getRequests() { + public ConcurrentHashMap> getRequests() { return super.requests; } } From 697d5718911d02b163e15b8e0b6e20792744f7ca Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 13:27:04 +0200 Subject: [PATCH 09/14] update .project --- kuzzle-sdk-java/.project | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 kuzzle-sdk-java/.project diff --git a/kuzzle-sdk-java/.project b/kuzzle-sdk-java/.project new file mode 100644 index 00000000..b264ce64 --- /dev/null +++ b/kuzzle-sdk-java/.project @@ -0,0 +1,17 @@ + + + kuzzle-sdk-java + Project kuzzle-sdk-java created by Buildship. + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.buildship.core.gradleprojectnature + + From fa4e0d6a3cd854bda959a845da04c699e7af0171 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 13:27:40 +0200 Subject: [PATCH 10/14] Revert "update .project" This reverts commit 697d5718911d02b163e15b8e0b6e20792744f7ca. --- kuzzle-sdk-java/.project | 17 ----------------- 1 file changed, 17 deletions(-) delete mode 100644 kuzzle-sdk-java/.project diff --git a/kuzzle-sdk-java/.project b/kuzzle-sdk-java/.project deleted file mode 100644 index b264ce64..00000000 --- a/kuzzle-sdk-java/.project +++ /dev/null @@ -1,17 +0,0 @@ - - - kuzzle-sdk-java - Project kuzzle-sdk-java created by Buildship. - - - - - org.eclipse.buildship.core.gradleprojectbuilder - - - - - - org.eclipse.buildship.core.gradleprojectnature - - From f09f73a87028a2d27870f7957b41cd8c0b2b5237 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 13:49:33 +0200 Subject: [PATCH 11/14] fix travis --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 47757f2c..838ad940 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,8 +15,8 @@ jobs: node_js: 10 before_script: - - npm run doc-prepare - - npm run --prefix doc/framework clone-repos + - cd kuzzle-sdk-java && npm run doc-prepare + - npm run --prefix doc/framework clone-repos && cd - script: - gem install typhoeus - HYDRA_MAX_CONCURRENCY=20 npm run --prefix doc/framework dead-links @@ -97,7 +97,7 @@ jobs: - $HOME/.gradle/caches/ - $HOME/.gradle/wrapper/ install: - - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-base + - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-java - gradle assemble - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-java - gradle assemble From b8414ecfe1f5b83edcfe480f238bf69e789a0080 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 13:57:09 +0200 Subject: [PATCH 12/14] fix travis --- .travis.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 838ad940..04a06c7b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -42,17 +42,17 @@ jobs: - cd $TRAVIS_BUILD_DIR/kuzzle-sdk-java - gradle assemble script: - - npm run doc-prepare - - npm run doc-build + - cd kuzzle-sdk-java && npm run doc-prepare + - npm run doc-build && cd - deploy: provider: script script: - - npm run doc-upload + - cd kuzzle-sdk-java && npm run doc-upload && cd - skip_cleanup: true after_deploy: - - npm run doc-cloudfront + - cd kuzzle-sdk-java && npm run doc-cloudfront && cd - - stage: Deployment Doc Prod name: Deploy docs.kuzzle.io From a18859ea5ce5bda48cd95f80f7bbe380afd41bc5 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 14:00:31 +0200 Subject: [PATCH 13/14] fix travis --- package.json => kuzzle-sdk-java/package.json | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename package.json => kuzzle-sdk-java/package.json (100%) diff --git a/package.json b/kuzzle-sdk-java/package.json similarity index 100% rename from package.json rename to kuzzle-sdk-java/package.json From 11d51610d340f7b8cc7e7507dba1908907e63018 Mon Sep 17 00:00:00 2001 From: ycombes Date: Mon, 16 Sep 2019 15:18:41 +0200 Subject: [PATCH 14/14] update gitignore --- .gitignore | 1 + kuzzle-sdk-java/.project | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 kuzzle-sdk-java/.project diff --git a/.gitignore b/.gitignore index 278a3ec2..aa646c06 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ build out .idea +bin *.iml *.class diff --git a/kuzzle-sdk-java/.project b/kuzzle-sdk-java/.project new file mode 100644 index 00000000..1a097e23 --- /dev/null +++ b/kuzzle-sdk-java/.project @@ -0,0 +1,23 @@ + + + kuzzle-sdk-java + Project kuzzle-sdk-java created by Buildship. + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.buildship.core.gradleprojectnature + +