diff --git a/dist/java/build.gradle b/dist/java/build.gradle index 0f41fd2..503dd4b 100644 --- a/dist/java/build.gradle +++ b/dist/java/build.gradle @@ -1,7 +1,7 @@ plugins { id 'java-library' - id "com.vanniktech.maven.publish.base" version "0.30.0" - id 'com.google.osdetector' version '1.7.3' + alias libs.plugins.maven.publish + alias libs.plugins.osdetector } group = 'mp.code' @@ -107,11 +107,18 @@ repositories { sourceSets { main.java.srcDirs = ['src/'] + test.java.srcDirs = ['src-test/'] } dependencies { - compileOnly 'org.projectlombok:lombok:1.18.34' - annotationProcessor 'org.projectlombok:lombok:1.18.34' + compileOnly libs.lombok + annotationProcessor libs.lombok + testImplementation libs.junit.jupiter + testImplementation(platform(libs.junit.bom)) +} + +test { + useJUnitPlatform() } tasks.register('cargoBuild', Exec) { @@ -156,7 +163,7 @@ import com.vanniktech.maven.publish.SonatypeHost mavenPublishing { publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL, true) signAllPublications() - coordinates(project.group, rootProject.name, project.version) + coordinates(project.group as String, rootProject.name, project.version as String) pom { name = rootProject.name @@ -183,3 +190,6 @@ mavenPublishing { } } } + +// useful for debugging +test.doFirst { environment 'RUST_BACKTRACE', 'full' } diff --git a/dist/java/libs.versions.toml b/dist/java/libs.versions.toml new file mode 100644 index 0000000..58bfbc4 --- /dev/null +++ b/dist/java/libs.versions.toml @@ -0,0 +1,14 @@ +[versions] +lombok = '1.18.34' +junit = '5.11.0' +maven-publish = '0.30.0' +osdetector = '1.7.3' + +[plugins] +maven-publish = { id = 'com.vanniktech.maven.publish.base', version.ref = 'maven-publish' } +osdetector = { id = 'com.google.osdetector', version.ref = 'osdetector' } + +[libraries] +lombok = { group = 'org.projectlombok', name = 'lombok', version.ref = 'lombok' } +junit-jupiter = { group = 'org.junit.jupiter', name = 'junit-jupiter', version.ref = 'junit' } +junit-bom = { group = 'org.junit', name = 'junit-bom', version.ref = 'junit' } diff --git a/dist/java/settings.gradle b/dist/java/settings.gradle index c1b754b..a9e43d9 100644 --- a/dist/java/settings.gradle +++ b/dist/java/settings.gradle @@ -1 +1,9 @@ rootProject.name = 'codemp' +dependencyResolutionManagement { + versionCatalogs { + libs { + from(files('libs.versions.toml')) + } + } +} + diff --git a/dist/java/src-test/CodeMPTest.java b/dist/java/src-test/CodeMPTest.java new file mode 100644 index 0000000..ce75b97 --- /dev/null +++ b/dist/java/src-test/CodeMPTest.java @@ -0,0 +1,239 @@ +import mp.code.*; +import mp.code.data.Config; +import mp.code.data.Cursor; +import mp.code.data.TextChange; +import mp.code.data.User; +import mp.code.exceptions.ConnectionException; +import mp.code.exceptions.ConnectionRemoteException; +import mp.code.exceptions.ControllerException; +import org.junit.jupiter.api.Test; + +import java.util.Objects; +import java.util.Optional; +import java.util.OptionalLong; +import java.util.UUID; + +import static mp.code.data.DetachResult.DETACHING; + +public class CodeMPTest { + private final Client client; + private final Client otherClient; + + // client connection init + public CodeMPTest() throws ConnectionException { + System.out.println("aaaa"); + //new Thread(() -> Extensions.drive(true)); // drive thread so callback works + Extensions.setupTracing(null, true); + + this.client = Client.connect(new Config( + Objects.requireNonNull(System.getenv("CODEMP_TEST_USERNAME_1")), + Objects.requireNonNull(System.getenv("CODEMP_TEST_PASSWORD_1")), + "api.codemp.dev", + 50053, + false + )); + + this.otherClient = Client.connect(new Config( + Objects.requireNonNull(System.getenv("CODEMP_TEST_USERNAME_2")), + Objects.requireNonNull(System.getenv("CODEMP_TEST_PASSWORD_2")), + "api.code.mp", + 50053, + false + )); + } + + @Test + void testGetUser() { + User u = this.client.getUser(); + System.out.println("User name:" + u.name); + System.out.println("User ID: " + u.id); + } + + @Test + void testWorkspaceInteraction() throws ConnectionException { + String randomName = UUID.randomUUID().toString(); + + int oldOwned = this.client.listWorkspaces(true, false).length; + int oldInvited = this.client.listWorkspaces(false, true).length; + this.client.createWorkspace(randomName); + assert (oldOwned + 1) == this.client.listWorkspaces(true, false).length; + assert oldInvited == this.client.listWorkspaces(false, true).length; + + int activeWorkspaces = this.client.activeWorkspaces().length; + this.client.joinWorkspace(randomName); + assert (activeWorkspaces + 1) == this.client.activeWorkspaces().length; + + Optional ws = this.client.getWorkspace(randomName); + assert ws.isPresent(); + assert ws.get().getWorkspaceId().equals(randomName); + ws.get().fetchBuffers(); + ws.get().fetchUsers(); + + this.client.inviteToWorkspace(randomName, this.otherClient.getUser().name); + assert this.client.leaveWorkspace(randomName); + assert this.otherClient.leaveWorkspace(randomName); + + this.client.deleteWorkspace(randomName); + } + + @Test + void testRefresh() throws ConnectionRemoteException { + this.client.refresh(); + } + + @Test + void testBufferInteractions() throws ConnectionException, ControllerException, InterruptedException { + String randomWorkspace = UUID.randomUUID().toString(); + String randomBuffer = UUID.randomUUID().toString(); + this.client.createWorkspace(randomWorkspace); + Workspace ws = this.client.joinWorkspace(randomWorkspace); + + this.client.inviteToWorkspace(ws.getWorkspaceId(), this.otherClient.getUser().name); + + int oldFileTree = ws.getFileTree(Optional.empty(), true).length; + ws.createBuffer(randomBuffer); + assert (oldFileTree + 1) == ws.getFileTree(Optional.empty(), true).length; + + assert ws.getFileTree(Optional.of(randomBuffer.substring(0, 10)), true).length == 0; + assert ws.getFileTree(Optional.of(randomBuffer.substring(0, 10)), false).length == 1; + + ws.deleteBuffer(randomBuffer); + assert oldFileTree == ws.getFileTree(Optional.empty(), true).length; + + ws.createBuffer(randomBuffer); + + int oldActive = ws.activeBuffers().length; + ws.attachToBuffer(randomBuffer); + assert (oldActive + 1) == ws.activeBuffers().length; + + Optional buffer = ws.getBuffer(randomBuffer); + assert buffer.isPresent(); + + buffer.get().callback(bufferController -> { + assert true; + }); + + Thread t = new Thread(() -> parallelBufferThreadTask(randomWorkspace, randomBuffer)); + t.start(); + + // wait for other thread to attach + while(ws.listBufferUsers(randomBuffer).length == 1) { + wait(50); + } + + buffer.get().poll(); + buffer.get().clearCallback(); + + buffer.get().recv(); + + buffer.get().poll(); + assert buffer.get().tryRecv().isPresent(); + + assert buffer.get().tryRecv().isEmpty(); + + buffer.get().send(new TextChange(0, 0, "1", OptionalLong.empty())); + + assert ws.detachFromBuffer(randomBuffer) == DETACHING; + ws.deleteBuffer(randomBuffer); + + assert ws.event().getChangedBuffer().isPresent(); + t.join(1000); + + this.client.leaveWorkspace(randomWorkspace); + this.client.deleteWorkspace(randomWorkspace); + } + + private void parallelBufferThreadTask(String workspace, String buffer) { + try { + Workspace w = this.otherClient.joinWorkspace(workspace); + BufferController controller = w.attachToBuffer(buffer); + for(int i = 0; i < 3; i++) { + try { + wait(200); + controller.send(new TextChange( + 0, 0, "1", OptionalLong.empty() + )); + } catch(InterruptedException e) { + break; + } + } + w.detachFromBuffer(buffer); + + String anotherRandomBuffer = UUID.randomUUID().toString(); + w.createBuffer(anotherRandomBuffer); + w.deleteBuffer(anotherRandomBuffer); + } catch(ConnectionException | ControllerException e) { + throw new RuntimeException(e); + } + } + + @Test + void testCursorInteractions() throws ConnectionException, InterruptedException, ControllerException { + String randomWorkspace = UUID.randomUUID().toString(); + String randomBuffer = UUID.randomUUID().toString(); + + // prepare first client + this.client.createWorkspace(randomWorkspace); + Workspace ws = this.client.joinWorkspace(randomWorkspace); + this.client.inviteToWorkspace(ws.getWorkspaceId(), this.otherClient.getUser().name); + ws.createBuffer(randomBuffer); + ws.attachToBuffer(randomBuffer); + CursorController cursor = ws.getCursor(); + + // prepare second client (ignore initial cursor for convenience) + this.otherClient.joinWorkspace(randomWorkspace).attachToBuffer(randomBuffer); + + cursor.callback(bufferController -> { + assert true; + }); + + Thread t = new Thread(() -> parallelCursorThreadTask(randomWorkspace, randomBuffer)); + t.start(); + + // wait for other thread to attach + while(ws.listBufferUsers(randomBuffer).length == 1) { + wait(50); + } + + cursor.poll(); + cursor.clearCallback(); + + cursor.recv(); + + cursor.poll(); + assert cursor.tryRecv().isPresent(); + + assert cursor.tryRecv().isEmpty(); + + cursor.send(new Cursor(0, 0, 0, 0, randomBuffer, this.client.getUser().name)); + + assert ws.detachFromBuffer(randomBuffer) == DETACHING; + ws.deleteBuffer(randomBuffer); + + t.join(1000); + + this.client.leaveWorkspace(randomWorkspace); + this.client.deleteWorkspace(randomWorkspace); + + } + + private void parallelCursorThreadTask(String workspace, String buffer) { + try { + @SuppressWarnings("OptionalGetWithoutIsPresent") + Workspace w = this.otherClient.getWorkspace(workspace).get(); + for(int i = 0; i < 3; i++) { + try { + wait(200); + w.getCursor().send(new Cursor( + 0, 0, 0, 0, buffer, this.otherClient.getUser().name + )); + } catch(InterruptedException e) { + break; + } + } + w.detachFromBuffer(buffer); + } catch(ControllerException e) { + throw new RuntimeException(e); + } + } +}