Skip to content

Commit

Permalink
fix(java): fix (most) unit tests
Browse files Browse the repository at this point in the history 
However, as mentioned in the text for the PR, we'll be ditching these
to work on the Rust ones. I'm committing what I had here to not lose it,
but these will probably be rustified.
  • Loading branch information
@zaaarf
zaaarf committed Oct 16, 2024
1 parent f6f16b5 commit c7bd2a7
Showing 1 changed file with 93 additions and 106 deletions.
199 changes: 93 additions & 106 deletions dist/java/src-test/CodeMPTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
import mp.code.exceptions.ConnectionException;
import mp.code.exceptions.ConnectionRemoteException;
import mp.code.exceptions.ControllerException;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.Objects;
Expand All @@ -15,15 +16,15 @@

import static mp.code.data.DetachResult.DETACHING;

@SuppressWarnings({"StatementWithEmptyBody", "OptionalGetWithoutIsPresent"})
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);
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")),
Expand All @@ -33,6 +34,11 @@ public CodeMPTest() throws ConnectionException {
false
));

// failed tests may have cluttered the list, clean it first
for(String ws : this.client.listWorkspaces(true, false)) {
this.client.deleteWorkspace(ws);
}

this.otherClient = Client.connect(new Config(
Objects.requireNonNull(System.getenv("CODEMP_TEST_USERNAME_2")),
Objects.requireNonNull(System.getenv("CODEMP_TEST_PASSWORD_2")),
Expand All @@ -45,12 +51,12 @@ public CodeMPTest() throws ConnectionException {
@Test
void testGetUser() {
User u = this.client.getUser();
System.out.println("User name:" + u.name);
System.out.println("User ID: " + u.id);
//assert u.name.equals(System.getenv("CODEMP_TEST_USERNAME_1"));
//assert u.id.toString().equals(System.getenv("CODEMP_TEST_ID_1"));
}

@Test
void testWorkspaceInteraction() throws ConnectionException {
void testWorkspaceInteractions() throws ConnectionException {
String randomName = UUID.randomUUID().toString();

int oldOwned = this.client.listWorkspaces(true, false).length;
Expand All @@ -71,7 +77,7 @@ void testWorkspaceInteraction() throws ConnectionException {

this.client.inviteToWorkspace(randomName, this.otherClient.getUser().name);
assert this.client.leaveWorkspace(randomName);
assert this.otherClient.leaveWorkspace(randomName);
assert !this.otherClient.leaveWorkspace(randomName);

this.client.deleteWorkspace(randomName);
}
Expand All @@ -85,155 +91,136 @@ void testRefresh() throws ConnectionRemoteException {
void testBufferInteractions() throws ConnectionException, ControllerException, InterruptedException {
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);

// test buffer creation and verify that the buffer list has changed
int oldFileTree = ws.getFileTree(Optional.empty(), true).length;
ws.createBuffer(randomBuffer);
assert (oldFileTree + 1) == ws.getFileTree(Optional.empty(), true).length;

// test buffer filters
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<BufferController> buffer = ws.getBuffer(randomBuffer);
assert buffer.isPresent();
BufferController buffer = ws.getBuffer(randomBuffer).get();

buffer.get().callback(bufferController -> {
assert true;
});

Thread t = new Thread(() -> parallelBufferThreadTask(randomWorkspace, randomBuffer));
t.start();
// prepare second client and clean queue
this.client.inviteToWorkspace(ws.getWorkspaceId(), this.otherClient.getUser().name);
BufferController otherBuffer = this.otherClient.joinWorkspace(randomWorkspace).attachToBuffer(randomBuffer);
while(buffer.tryRecv().isPresent()) {}

// wait for other thread to attach
while(ws.listBufferUsers(randomBuffer).length == 1) {
wait(50);
}
TextChange textChange = new TextChange(0, 0, "", OptionalLong.empty());

buffer.get().poll();
buffer.get().clearCallback();
/* Testing callback */
buffer.callback(bufferController -> new Thread(() -> {
try {
assert bufferController.recv().equals(textChange);
} catch(ControllerException e) {
throw new RuntimeException(e);
}
}).start());

buffer.get().recv();
otherBuffer.send(textChange);
buffer.poll();
buffer.clearCallback();

buffer.get().poll();
assert buffer.get().tryRecv().isPresent();
otherBuffer.send(textChange);
buffer.recv();

assert buffer.get().tryRecv().isEmpty();
otherBuffer.send(textChange);
buffer.poll();
assert buffer.tryRecv().isPresent();

buffer.get().send(new TextChange(0, 0, "1", OptionalLong.empty()));
assert buffer.tryRecv().isEmpty();

assert ws.detachFromBuffer(randomBuffer) == DETACHING;
ws.deleteBuffer(randomBuffer);

this.otherClient.getWorkspace(randomWorkspace).get().createBuffer(UUID.randomUUID().toString());
assert ws.event().getChangedBuffer().isPresent();
t.join(1000);

ws.deleteBuffer(randomBuffer);
Assertions.assertEquals(oldFileTree, ws.getFileTree(Optional.empty(), true).length);

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);
@Test
void testWorkspaceEvents() throws ConnectionException, ControllerException {
String randomWorkspace = UUID.randomUUID().toString();

String anotherRandomBuffer = UUID.randomUUID().toString();
w.createBuffer(anotherRandomBuffer);
w.deleteBuffer(anotherRandomBuffer);
} catch(ConnectionException | ControllerException e) {
throw new RuntimeException(e);
}
// prepare first client
this.client.createWorkspace(randomWorkspace);
Workspace ws = this.client.joinWorkspace(randomWorkspace);
this.client.inviteToWorkspace(randomWorkspace, this.otherClient.getUser().name);

// prepare second client
this.otherClient.joinWorkspace(randomWorkspace).createBuffer(UUID.randomUUID().toString());

// block until event is received
assert ws.event().getChangedBuffer().isPresent();

// cleanup
this.otherClient.leaveWorkspace(randomWorkspace);
this.client.deleteWorkspace(randomWorkspace);
}

@Test
void testCursorInteractions() throws ConnectionException, InterruptedException, ControllerException {
void testCursorInteractions() throws ConnectionException, ControllerException, InterruptedException {
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);
}
// prepare second client and clean queue
this.client.inviteToWorkspace(ws.getWorkspaceId(), this.otherClient.getUser().name);
CursorController otherCursor = this.otherClient.joinWorkspace(randomWorkspace).getCursor();
while(cursor.tryRecv().isPresent()) {}

Cursor someCursor = new Cursor(
0, 0, 0, 0, randomBuffer, this.otherClient.getUser().name
);

/* Testing callback */
cursor.callback(cursorController -> new Thread(() -> {
try {
assert cursorController.recv().equals(someCursor);
} catch(ControllerException e) {
throw new RuntimeException(e);
}
}).start());

cursor.poll();
cursor.clearCallback();
otherCursor.send(someCursor);
cursor.poll(); // wait for other thread to send
cursor.clearCallback(); // should have now received the first callback, clear it

cursor.recv();
/* Testing recv and tryRecv */
otherCursor.send(someCursor);
cursor.recv(); // block until receive

// send flat cursor
otherCursor.send(new Cursor(
0, 0, 0, 0, randomBuffer, this.otherClient.getUser().name
));
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);
assert cursor.tryRecv().isPresent(); // expect something (and consume)
assert cursor.tryRecv().isEmpty(); // expect nothing

// cleanup
this.otherClient.leaveWorkspace(randomWorkspace);
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);
}
}
}

0 comments on commit c7bd2a7

Please sign in to comment.