codemp/dist/java/src-test/CodeMPTest.java

227 lines
7.4 KiB
Java
Raw Normal View History

2024-09-26 02:29:22 +02:00
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.Assertions;
2024-09-26 02:29:22 +02:00
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;
@SuppressWarnings({"StatementWithEmptyBody", "OptionalGetWithoutIsPresent"})
2024-09-26 02:29:22 +02:00
public class CodeMPTest {
private final Client client;
private final Client otherClient;
// client connection init
public CodeMPTest() throws ConnectionException {
new Thread(() -> Extensions.drive(true)); // drive thread so callback works
//Extensions.setupTracing(null, true);
2024-09-26 02:29:22 +02:00
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
));
// failed tests may have cluttered the list, clean it first
for(String ws : this.client.listWorkspaces(true, false)) {
this.client.deleteWorkspace(ws);
}
2024-09-26 02:29:22 +02:00
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();
//assert u.name.equals(System.getenv("CODEMP_TEST_USERNAME_1"));
//assert u.id.toString().equals(System.getenv("CODEMP_TEST_ID_1"));
2024-09-26 02:29:22 +02:00
}
@Test
void testWorkspaceInteractions() throws ConnectionException {
2024-09-26 02:29:22 +02:00
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<Workspace> 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);
2024-09-26 02:29:22 +02:00
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();
// prepare first client
2024-09-26 02:29:22 +02:00
this.client.createWorkspace(randomWorkspace);
Workspace ws = this.client.joinWorkspace(randomWorkspace);
// test buffer creation and verify that the buffer list has changed
2024-09-26 02:29:22 +02:00
int oldFileTree = ws.getFileTree(Optional.empty(), true).length;
ws.createBuffer(randomBuffer);
assert (oldFileTree + 1) == ws.getFileTree(Optional.empty(), true).length;
// test buffer filters
2024-09-26 02:29:22 +02:00
assert ws.getFileTree(Optional.of(randomBuffer.substring(0, 10)), true).length == 0;
assert ws.getFileTree(Optional.of(randomBuffer.substring(0, 10)), false).length == 1;
int oldActive = ws.activeBuffers().length;
ws.attachToBuffer(randomBuffer);
assert (oldActive + 1) == ws.activeBuffers().length;
BufferController buffer = ws.getBuffer(randomBuffer).get();
2024-09-26 02:29:22 +02:00
// 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()) {}
2024-09-26 02:29:22 +02:00
TextChange textChange = new TextChange(0, 0, "", OptionalLong.empty());
2024-09-26 02:29:22 +02:00
/* Testing callback */
buffer.callback(bufferController -> new Thread(() -> {
try {
assert bufferController.recv().equals(textChange);
} catch(ControllerException e) {
throw new RuntimeException(e);
}
}).start());
2024-09-26 02:29:22 +02:00
otherBuffer.send(textChange);
buffer.poll();
buffer.clearCallback();
2024-09-26 02:29:22 +02:00
otherBuffer.send(textChange);
buffer.recv();
2024-09-26 02:29:22 +02:00
otherBuffer.send(textChange);
buffer.poll();
assert buffer.tryRecv().isPresent();
2024-09-26 02:29:22 +02:00
assert buffer.tryRecv().isEmpty();
2024-09-26 02:29:22 +02:00
assert ws.detachFromBuffer(randomBuffer) == DETACHING;
this.otherClient.getWorkspace(randomWorkspace).get().createBuffer(UUID.randomUUID().toString());
2024-09-26 02:29:22 +02:00
assert ws.event().getChangedBuffer().isPresent();
ws.deleteBuffer(randomBuffer);
Assertions.assertEquals(oldFileTree, ws.getFileTree(Optional.empty(), true).length);
2024-09-26 02:29:22 +02:00
this.client.leaveWorkspace(randomWorkspace);
this.client.deleteWorkspace(randomWorkspace);
}
@Test
void testWorkspaceEvents() throws ConnectionException, ControllerException {
String randomWorkspace = UUID.randomUUID().toString();
2024-09-26 02:29:22 +02:00
// 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);
2024-09-26 02:29:22 +02:00
}
@Test
void testCursorInteractions() throws ConnectionException, ControllerException, InterruptedException {
2024-09-26 02:29:22 +02:00
String randomWorkspace = UUID.randomUUID().toString();
String randomBuffer = UUID.randomUUID().toString();
// prepare first client
this.client.createWorkspace(randomWorkspace);
Workspace ws = this.client.joinWorkspace(randomWorkspace);
ws.createBuffer(randomBuffer);
ws.attachToBuffer(randomBuffer);
CursorController cursor = ws.getCursor();
// 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());
2024-09-26 02:29:22 +02:00
otherCursor.send(someCursor);
cursor.poll(); // wait for other thread to send
cursor.clearCallback(); // should have now received the first callback, clear it
2024-09-26 02:29:22 +02:00
/* Testing recv and tryRecv */
otherCursor.send(someCursor);
cursor.recv(); // block until receive
2024-09-26 02:29:22 +02:00
// send flat cursor
otherCursor.send(new Cursor(
0, 0, 0, 0, randomBuffer, this.otherClient.getUser().name
));
2024-09-26 02:29:22 +02:00
cursor.poll();
assert cursor.tryRecv().isPresent(); // expect something (and consume)
assert cursor.tryRecv().isEmpty(); // expect nothing
2024-09-26 02:29:22 +02:00
// cleanup
this.otherClient.leaveWorkspace(randomWorkspace);
2024-09-26 02:29:22 +02:00
this.client.leaveWorkspace(randomWorkspace);
this.client.deleteWorkspace(randomWorkspace);
}
}