Create test framework

.github/workflows/test.yml

@@ -0,0 +1,52 @@
+name: Gradle build
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        subproject:
+          - 1.17.1-forge
+          - 1.17.1-fabric
+          - 1.18.2-forge
+          - 1.18.2-fabric
+          - 1.19.2-forge
+          - 1.19.2-fabric
+          - 1.19.4-forge
+          - 1.19.4-fabric
+          - 1.20.1-forge
+          - 1.20.1-fabric
+          - 1.20.4-neoforge
+          - 1.20.4-fabric
+          - 1.20.6-neoforge
+          - 1.20.6-fabric
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get cache key
+        id: cache_key
+        run: echo "gradle_key=gradle-`cat versions/mainProject`" >> $GITHUB_OUTPUT
+      - name: Cache Gradle stuff
+        uses: actions/cache@v3
+        with:
+          key: ${{ steps.cache_key.outputs.gradle_key }}-${{ hashFiles('*.gradle.kts', 'gradle.properties', 'gradle/**') }}
+          restore-keys: ${{ steps.cache_key.outputs.gradle_key }}-
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+            .gradle/loom-cache
+      - name: Set up JDK 21
+        uses: actions/setup-java@v1
+        with:
+          java-version: 21
+      - name: Install Xvfb
+        run: apt install xvfb
+      - name: Launch Xvfb
+        run: screen -d -m Xvfb :1 -screen 0 1920x1080x24
+      - name: Run tests
+        run: |
+          ./gradlew :${{ matrix.subproject }}:runTestHost --stacktrace &
+          ./gradlew :${{ matrix.subproject }}:runTestJoiner --stacktrace &&
+          fg
+      - name: Stop Xvfb
+        run: screen -X quit

src/main/java/io/github/gaming32/worldhost/WorldHostConfig.java

@@ -5,6 +5,7 @@
 import org.quiltmc.parsers.json.JsonWriter;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.UUID;
@@ -32,7 +33,7 @@ public class WorldHostConfig {
 
     private boolean announceFriendsOnline = true;
 
-    private final Set<UUID> friends = new LinkedHashSet<>();
+    private final Set<UUID> friends = Collections.synchronizedSet(new LinkedHashSet<>());
 
     public void read(JsonReader reader) throws IOException {
         reader.beginObject();

src/main/java/io/github/gaming32/worldhost/gui/screen/AddFriendScreen.java

@@ -87,11 +87,22 @@ protected void init() {
         }
         if (usernameResponder == null) {
             // Only set the responder here on first init
-            usernameField.setResponder(usernameResponder = text -> {
+            usernameField.setResponder(usernameResponder = username -> {
                 lastTyping = Util.getMillis();
-                usernameUpdate = true;
-                friendProfile = null;
-                addFriendButton.active = false;
+                if (VALID_USERNAME.matcher(username).matches()) {
+                    usernameUpdate = true;
+                    friendProfile = null;
+                    addFriendButton.active = false;
+                } else if (VALID_UUID.matcher(username).matches()) {
+                    usernameUpdate = false;
+                    friendProfile = new GameProfile(UUID.fromString(username), "");
+                    addFriendButton.active = true;
+                } else if (username.startsWith("o:")) {
+                    usernameUpdate = false;
+                    final String actualName = username.substring(2);
+                    friendProfile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + actualName).getBytes(StandardCharsets.UTF_8)), actualName);
+                    addFriendButton.active = true;
+                }
             });
         }
     }
@@ -137,24 +148,15 @@ public void tick() {
         if (Util.getMillis() - 300 > lastTyping && usernameUpdate) {
             usernameUpdate = false;
             final String username = usernameField.getValue();
-            if (VALID_USERNAME.matcher(username).matches()) {
-                WorldHost.getMaybeAsync(WorldHost.getProfileCache(), username, p -> {
-                    if (p.isPresent()) {
-                        assert minecraft != null;
-                        friendProfile = WorldHost.fetchProfile(minecraft.getMinecraftSessionService(), p.get());
-                        addFriendButton.active = true;
-                    } else {
-                        friendProfile = null;
-                    }
-                });
-            } else if (VALID_UUID.matcher(username).matches()) {
-                friendProfile = new GameProfile(UUID.fromString(username), "");
-                addFriendButton.active = true;
-            } else if (username.startsWith("o:")) {
-                final String actualName = username.substring(2);
-                friendProfile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + actualName).getBytes(StandardCharsets.UTF_8)), actualName);
-                addFriendButton.active = true;
-            }
+            WorldHost.getMaybeAsync(WorldHost.getProfileCache(), username, p -> {
+                if (p.isPresent()) {
+                    assert minecraft != null;
+                    friendProfile = WorldHost.fetchProfile(minecraft.getMinecraftSessionService(), p.get());
+                    addFriendButton.active = true;
+                } else {
+                    friendProfile = null;
+                }
+            });
         }
     }
 

src/main/java/io/github/gaming32/worldhost/gui/screen/OnlineFriendsScreen.java

@@ -280,9 +280,13 @@ public int getRowWidth() {
         }
 
         @Override
-        protected int getRowTop(int index) {
+        public int getRowTop(int index) {
             return super.getRowTop(index);
         }
+
+        public int getItemHeight() {
+            return itemHeight;
+        }
     }
 
     public class OnlineFriendsListEntry extends ObjectSelectionList.Entry<OnlineFriendsListEntry> {

src/main/java/io/github/gaming32/worldhost/mixin/DisconnectedScreenAccessor.java

@@ -0,0 +1,12 @@
+package io.github.gaming32.worldhost.mixin;
+
+import net.minecraft.client.gui.screens.DisconnectedScreen;
+import net.minecraft.network.chat.Component;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(DisconnectedScreen.class)
+public interface DisconnectedScreenAccessor {
+    @Accessor
+    Component getReason();
+}

src/main/java/io/github/gaming32/worldhost/mixin/MixinInputConstants.java

@@ -0,0 +1,48 @@
+package io.github.gaming32.worldhost.mixin;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import io.github.gaming32.worldhost.testing.WorldHostTesting;
+import io.github.gaming32.worldhost.testing.WindowCallbackManager;
+import org.lwjgl.glfw.GLFWCharModsCallbackI;
+import org.lwjgl.glfw.GLFWCursorPosCallbackI;
+import org.lwjgl.glfw.GLFWDropCallbackI;
+import org.lwjgl.glfw.GLFWKeyCallbackI;
+import org.lwjgl.glfw.GLFWMouseButtonCallbackI;
+import org.lwjgl.glfw.GLFWScrollCallbackI;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(InputConstants.class)
+public class MixinInputConstants {
+    @Inject(method = "setupKeyboardCallbacks", at = @At("HEAD"), cancellable = true)
+    private static void mockKeyboardCallbacks(
+        long window,
+        GLFWKeyCallbackI keyCallback,
+        GLFWCharModsCallbackI charModifierCallback,
+        CallbackInfo ci
+    ) {
+        if (!WorldHostTesting.ENABLED) return;
+        WindowCallbackManager.keyCallback = keyCallback;
+        WindowCallbackManager.charModsCallback = charModifierCallback;
+        ci.cancel();
+    }
+
+    @Inject(method = "setupMouseCallbacks", at = @At("HEAD"), cancellable = true)
+    private static void mockMouseCallbacks(
+        long window,
+        GLFWCursorPosCallbackI cursorPositionCallback,
+        GLFWMouseButtonCallbackI mouseButtonCallback,
+        GLFWScrollCallbackI scrollCallback,
+        GLFWDropCallbackI dragAndDropCallback,
+        CallbackInfo ci
+    ) {
+        if (!WorldHostTesting.ENABLED) return;
+        WindowCallbackManager.cursorPosCallback = cursorPositionCallback;
+        WindowCallbackManager.mouseButtonCallback = mouseButtonCallback;
+        WindowCallbackManager.scrollCallback = scrollCallback;
+        WindowCallbackManager.dropCallback = dragAndDropCallback;
+        ci.cancel();
+    }
+}

src/main/java/io/github/gaming32/worldhost/mixin/MixinMinecraft.java

@@ -2,17 +2,24 @@
 
 import io.github.gaming32.worldhost.WorldHost;
 import io.github.gaming32.worldhost.gui.screen.JoiningWorldHostScreen;
+import io.github.gaming32.worldhost.testing.ScreenChain;
+import io.github.gaming32.worldhost.testing.WorldHostTesting;
 import io.github.gaming32.worldhost.toast.WHToast;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.screens.ConnectScreen;
 import net.minecraft.client.gui.screens.Overlay;
 import net.minecraft.client.gui.screens.ProgressScreen;
 import net.minecraft.client.gui.screens.Screen;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.util.List;
+import java.util.function.Function;
+
 //#if MC < 1.19.4
 //$$ import com.mojang.blaze3d.platform.Window;
 //$$ import com.mojang.blaze3d.vertex.PoseStack;
@@ -36,23 +43,43 @@ public abstract class MixinMinecraft {
     //$$ @Shadow public abstract Window getWindow();
     //#endif
 
+    @Shadow public Screen screen;
+
+    @Unique
+    private Class<? extends Screen> wh$lastScreenClass;
+    @Unique
+    private boolean wh$readyForTesting;
+
     @Inject(method = "setOverlay", at = @At("HEAD"))
     private void deferredToastReady(Overlay loadingGui, CallbackInfo ci) {
         if (loadingGui == null) {
             WHToast.ready();
+            wh$readyForTesting = true;
         }
     }
 
     @Inject(method = "tick", at = @At("HEAD"))
-    private void toastTick(CallbackInfo ci) {
+    private void preTick(CallbackInfo ci) {
         WHToast.tick();
+        final var screenClass = ScreenChain.getScreenClass(screen);
+        if (WorldHostTesting.ENABLED && wh$readyForTesting && screenClass != wh$lastScreenClass) {
+            wh$lastScreenClass = screenClass;
+            WorldHostTesting.SCREEN_CHAIN.get().advance(screen);
+        }
     }
 
     @Inject(method = "tick", at = @At("RETURN"))
-    private void tickEvent(CallbackInfo ci) {
+    private void postTick(CallbackInfo ci) {
         WorldHost.tickHandler();
     }
 
+    @Inject(method = "addInitialScreens", at = @At("HEAD"), cancellable = true)
+    private void noOnboardingWhileTesting(List<Function<Runnable, Screen>> output, CallbackInfo ci) {
+        if (WorldHostTesting.ENABLED) {
+            ci.cancel();
+        }
+    }
+
     //#if MC < 1.19.4
     //$$ @Inject(
     //$$     method = "runTick",

src/main/java/io/github/gaming32/worldhost/mixin/MixinOptions.java

@@ -0,0 +1,21 @@
+package io.github.gaming32.worldhost.mixin;
+
+import io.github.gaming32.worldhost.testing.WorldHostTesting;
+import net.minecraft.client.Options;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Options.class)
+public class MixinOptions {
+    @Shadow public boolean pauseOnLostFocus;
+
+    @Inject(method = "load", at = @At("RETURN"))
+    private void dontPauseWhileTesting(CallbackInfo ci) {
+        if (WorldHostTesting.ENABLED) {
+            pauseOnLostFocus = false;
+        }
+    }
+}

src/main/java/io/github/gaming32/worldhost/protocol/ProtocolClient.java

@@ -205,6 +205,7 @@ public void listOnline(Collection<UUID> friends) {
     }
 
     public void publishedWorld(Collection<UUID> friends) {
+        WorldHost.LOGGER.info("Published world to friends: {}", friends);
         enqueue(new WorldHostC2SMessage.PublishedWorld(friends));
     }
 

src/main/java/io/github/gaming32/worldhost/protocol/WorldHostS2CMessage.java

@@ -17,6 +17,7 @@
 import java.io.IOException;
 import java.net.InetAddress;
 import java.nio.charset.StandardCharsets;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
 
@@ -78,6 +79,14 @@ record FriendRequest(UUID fromUser) implements WorldHostS2CMessage {
         public void handle(ProtocolClient client) {
             if (!WorldHost.CONFIG.isEnableFriends()) return;
             final boolean isFriend = WorldHost.isFriend(fromUser);
+            if (isFriend) {
+                Minecraft.getInstance().execute(() -> {
+                    final var server = Minecraft.getInstance().getSingleplayerServer();
+                    if (server != null && server.isPublished()) {
+                        client.publishedWorld(Collections.singleton(fromUser));
+                    }
+                });
+            }
             if (!isFriend && !WorldHost.CONFIG.isAllowFriendRequests()) return;
             WorldHost.showFriendOrOnlineToast(
                 fromUser,
@@ -100,10 +109,11 @@ public void handle(ProtocolClient client) {
     record PublishedWorld(UUID user, long connectionId) implements WorldHostS2CMessage {
         @Override
         public void handle(ProtocolClient client) {
-            if (!WorldHost.CONFIG.isAnnounceFriendsOnline() || !WorldHost.isFriend(user)) return;
+            if (!WorldHost.isFriend(user)) return;
             Minecraft.getInstance().execute(() -> {
                 WorldHost.ONLINE_FRIENDS.put(user, connectionId);
                 WorldHost.ONLINE_FRIEND_UPDATES.forEach(FriendsListUpdate::friendsListUpdate);
+                if (!WorldHost.CONFIG.isAnnounceFriendsOnline()) return;
                 WorldHost.showFriendOrOnlineToast(
                     user, "world-host.went_online", "world-host.went_online.desc", 200,
                     () -> WorldHost.join(connectionId, null)