public IEnumerator UnityTearDown() => UniTask.ToCoroutine(async() => { // check active, it might have been stopped by tests if (client.Active) { client.Disconnect(); } if (server.Active) { server.Stop(); } await AsyncUtil.WaitUntilWithTimeout(() => !client.Active); await AsyncUtil.WaitUntilWithTimeout(() => !server.Active); Object.DestroyImmediate(playerPrefab); Object.DestroyImmediate(serverGo); Object.DestroyImmediate(clientGo); Object.DestroyImmediate(serverPlayerGO); Object.DestroyImmediate(clientPlayerGO); TearDownTestObjects(); ExtraTearDown(); await ExtraTearDownAsync(); Console.WriteLine($"[MirageTest] UnityTearDown class:{TestContext.CurrentContext.Test.ClassName} method:{TestContext.CurrentContext.Test.MethodName}"); });
public IEnumerator ShutdownHost() => UniTask.ToCoroutine(async() => { // check active, it might have been stopped by tests if (client.Active) { client.Disconnect(); } if (server.Active) { server.Stop(); } await AsyncUtil.WaitUntilWithTimeout(() => !client.Active); await AsyncUtil.WaitUntilWithTimeout(() => !server.Active); Object.DestroyImmediate(playerPrefab); Object.DestroyImmediate(serverGo); Object.DestroyImmediate(clientGo); Object.DestroyImmediate(serverPlayerGO); Object.DestroyImmediate(clientPlayerGO); foreach (GameObject obj in toDestroy) { if (obj != null) { Object.DestroyImmediate(obj); } } ExtraTearDown(); });
public IEnumerator ClientSceneMessageInvokeTest() => UniTask.ToCoroutine(async() => { int startInvoked = 0; int endInvoked = 0; clientSceneManager.ClientChangeScene.AddListener((_, __) => startInvoked++); clientSceneManager.ClientSceneChanged.AddListener((_, __) => endInvoked++); clientSceneManager.ClientSceneMessage(null, new SceneMessage { scenePath = "Assets/Mirror/Tests/Runtime/testScene.unity" }); await AsyncUtil.WaitUntilWithTimeout(() => startInvoked == 1); // wait 1/2 a second to see if end invokes itself await UniTask.Delay(500); Assert.That(startInvoked == 1, "Start should only be called once"); Assert.That(endInvoked == 0, "Should wait for ready before end is called"); clientSceneManager.ClientSceneReadyMessage(connectionToServer, new SceneReadyMessage()); await AsyncUtil.WaitUntilWithTimeout(() => endInvoked == 1); Assert.That(clientSceneManager.ActiveScenePath, Is.EqualTo("Assets/Mirror/Tests/Runtime/testScene.unity")); Assert.That(startInvoked == 1, "Start should only be called once"); Assert.That(endInvoked == 1, "End should only be called once"); });
public IEnumerator SetupHost() => UniTask.ToCoroutine(async() => { networkManagerGo = new GameObject(); networkManagerGo.AddComponent <MockTransport>(); sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>(); serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>(); clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>(); manager = networkManagerGo.AddComponent <NetworkManager>(); manager.client = networkManagerGo.GetComponent <NetworkClient>(); manager.server = networkManagerGo.GetComponent <NetworkServer>(); server = manager.server; client = manager.client; sceneManager.client = client; sceneManager.server = server; serverObjectManager.server = server; serverObjectManager.networkSceneManager = sceneManager; clientObjectManager.client = client; clientObjectManager.networkSceneManager = sceneManager; ExtraSetup(); // wait for all Start() methods to get invoked await UniTask.DelayFrame(1); await StartHost(); playerGO = new GameObject("playerGO", typeof(Rigidbody)); identity = playerGO.AddComponent <NetworkIdentity>(); component = playerGO.AddComponent <T>(); serverObjectManager.AddPlayerForConnection(server.LocalConnection, playerGO); // wait for client to spawn it await AsyncUtil.WaitUntilWithTimeout(() => client.Connection.Identity != null); });
public IEnumerator ClientDisconnectTest() => UniTask.ToCoroutine(async() => { client.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => client._connectState == ConnectState.Disconnected); await AsyncUtil.WaitUntilWithTimeout(() => !client.Active); });
public IEnumerator SpawnObjectsFalseTest() => UniTask.ToCoroutine(async() => { server.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => !server.Active); Assert.That(serverObjectManager.SpawnObjects(), Is.False); });
public IEnumerator RemovePlayerForConnectionDestroyTest() => UniTask.ToCoroutine(async() => { serverObjectManager.RemovePlayerForConnection(connectionToClient, true); await AsyncUtil.WaitUntilWithTimeout(() => !clientIdentity); Assert.That(!serverPlayerGO); });
public IEnumerator ChangeTarget() => UniTask.ToCoroutine(async() => { serverComponent.target = serverPlayerGO; await AsyncUtil.WaitUntilWithTimeout(() => clientComponent.target != null); Assert.That(clientComponent.target, Is.SameAs(clientPlayerGO)); });
public IEnumerator ServerRpcWithNetworkIdentity() => UniTask.ToCoroutine(async() => { component.CmdNetworkIdentity(identity); await AsyncUtil.WaitUntilWithTimeout(() => component.cmdNi != null); Assert.That(component.cmdNi, Is.SameAs(identity)); });
public IEnumerator NetworkManagerModeOfflineHostTest() => UniTask.ToCoroutine(async() => { server.StopHost(); await AsyncUtil.WaitUntilWithTimeout(() => !server.Active && !client.Active); Assert.That(manager.NetworkMode == NetworkManagerMode.None); });
public IEnumerator ChangeSceneAdditiveLoadTest() => UniTask.ToCoroutine(async() => { sceneManager.ChangeServerScene("Assets/Mirror/Tests/Runtime/testScene.unity", SceneOperation.LoadAdditive); await AsyncUtil.WaitUntilWithTimeout(() => SceneManager.GetSceneByName("testScene") != null); Assert.That(SceneManager.GetSceneByName("testScene"), Is.Not.Null); });
public IEnumerator ServerRpcWithSenderOnServer() => UniTask.ToCoroutine(async() => { serverComponent.SendWithSender(1); await AsyncUtil.WaitUntilWithTimeout(() => serverComponent.cmdArg1 != 0); Assert.That(serverComponent.cmdArg1, Is.EqualTo(1)); Assert.That(serverComponent.cmdSender, Is.Null, "ServerRPC called on server will have no sender"); });
public IEnumerator ServerRpcWithSenderOnClient() => UniTask.ToCoroutine(async() => { clientComponent.SendWithSender(1); await AsyncUtil.WaitUntilWithTimeout(() => serverComponent.cmdArg1 != 0); Assert.That(serverComponent.cmdArg1, Is.EqualTo(1)); Assert.That(serverComponent.cmdSender, Is.EqualTo(serverPlayer), "ServerRpc called on client will have client's player (server version)"); });
public IEnumerator ClientDisconnectTest() => UniTask.ToCoroutine(async() => { var playerCount = server.Players.Count; client.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => client._connectState == ConnectState.Disconnected); // player could should be 1 less after client disconnects await AsyncUtil.WaitUntilWithTimeout(() => server.Players.Count == playerCount - 1); });
public IEnumerator ServerRpcWithSender() => UniTask.ToCoroutine(async() => { playerComponent.SendWithSender(1); await AsyncUtil.WaitUntilWithTimeout(() => playerComponent.cmdArg1 != 0); Assert.That(playerComponent.cmdArg1, Is.EqualTo(1)); Assert.That(playerComponent.cmdSender, Is.EqualTo(server.LocalPlayer), "Server Rpc call on host will have localplayer (server version) as sender"); });
public IEnumerator RegisterMessage1() => UniTask.ToCoroutine(async() => { var invoked = false; ServerMessageHandler.RegisterHandler <WovenTestMessage>(msg => invoked = true); clientPlayer.Send(message); await AsyncUtil.WaitUntilWithTimeout(() => invoked); });
public IEnumerator ClientOwnerRpc() => UniTask.ToCoroutine(async() => { component.RpcOwnerTest(1, "hello"); // process spawn message from server await AsyncUtil.WaitUntilWithTimeout(() => component.rpcOwnerArg1 != 0); Assert.That(component.rpcOwnerArg1, Is.EqualTo(1)); Assert.That(component.rpcOwnerArg2, Is.EqualTo("hello")); });
public IEnumerator ServerRpc() => UniTask.ToCoroutine(async() => { component.Test(1, "hello"); await AsyncUtil.WaitUntilWithTimeout(() => component.cmdArg1 != 0); Assert.That(component.cmdArg1, Is.EqualTo(1)); Assert.That(component.cmdArg2, Is.EqualTo("hello")); });
public IEnumerator ReadyMessageSetsClientReadyTest() => UniTask.ToCoroutine(async() => { connectionToServer.Send(new ReadyMessage()); await AsyncUtil.WaitUntilWithTimeout(() => connectionToClient.IsReady); // ready? Assert.That(connectionToClient.IsReady, Is.True); });
public IEnumerator RegisterMessage1() => UniTask.ToCoroutine(async() => { bool invoked = false; connectionToClient.RegisterHandler <WovenTestMessage>(msg => invoked = true); connectionToServer.Send(message); await AsyncUtil.WaitUntilWithTimeout(() => invoked); });
public IEnumerator ReadyMessageSetsClientReadyTest() => UniTask.ToCoroutine(async() => { clientPlayer.Send(new SceneReadyMessage()); await AsyncUtil.WaitUntilWithTimeout(() => serverPlayer.SceneIsReady); // ready? Assert.That(serverPlayer.SceneIsReady, Is.True); });
public IEnumerator ClientReadyTest() => UniTask.ToCoroutine(async() => { NetworkIdentity readyPlayer = CreateNetworkIdentity(); readyComp = readyPlayer.gameObject.AddComponent <ObjectReady>(); serverObjectManager.Spawn(readyPlayer, server.LocalPlayer); readyComp.Ready(); await AsyncUtil.WaitUntilWithTimeout(() => readyComp.IsReady); });
public IEnumerator ClientConnRpc() => UniTask.ToCoroutine(async() => { component.ClientConnRpcTest(manager.Server.LocalConnection, 1, "hello"); // process spawn message from server await AsyncUtil.WaitUntilWithTimeout(() => component.targetRpcArg1 != 0); Assert.That(component.targetRpcConn, Is.SameAs(manager.Client.Connection)); Assert.That(component.targetRpcArg1, Is.EqualTo(1)); Assert.That(component.targetRpcArg2, Is.EqualTo("hello")); });
public IEnumerator ClientConnRpc() => UniTask.ToCoroutine(async() => { playerComponent.ClientConnRpcTest(manager.Server.LocalPlayer, 1, "hello"); // process spawn message from server await AsyncUtil.WaitUntilWithTimeout(() => playerComponent.targetRpcArg1 != 0); Assert.That(playerComponent.targetRpcPlayer, Is.EqualTo(manager.Client.Player)); Assert.That(playerComponent.targetRpcArg1, Is.EqualTo(1)); Assert.That(playerComponent.targetRpcArg2, Is.EqualTo("hello")); });
public IEnumerator StopButtonTest() => UniTask.ToCoroutine(async() => { networkManagerHud.StopButtonHandler(); Assert.That(networkManagerHud.OfflineGO.activeSelf, Is.True); Assert.That(networkManagerHud.OnlineGO.activeSelf, Is.False); await AsyncUtil.WaitUntilWithTimeout(() => !manager.IsNetworkActive); Assert.That(manager.IsNetworkActive, Is.False); });
public IEnumerator ClientConnRpc() => UniTask.ToCoroutine(async() => { serverComponent.ClientConnRpcTest(connectionToClient, 1, "hello"); // process spawn message from server await AsyncUtil.WaitUntilWithTimeout(() => clientComponent.targetRpcArg1 != 0); Assert.That(clientComponent.targetRpcPlayer, Is.SameAs(connectionToServer)); Assert.That(clientComponent.targetRpcArg1, Is.EqualTo(1)); Assert.That(clientComponent.targetRpcArg2, Is.EqualTo("hello")); });
public IEnumerator IsNetworkActiveStopTest() => UniTask.ToCoroutine(async() => { manager.Server.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => !client.Active); Assert.That(server.Active, Is.False); Assert.That(client.Active, Is.False); Assert.That(manager.IsNetworkActive, Is.False); });
public IEnumerator ClientOfflineSceneException() => UniTask.ToCoroutine(async() => { client.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => !client.Active); Assert.Throws <InvalidOperationException>(() => { clientSceneManager.ClientSceneMessage(null, new SceneMessage()); }); });
public IEnumerator ObjectDestroyTest() => UniTask.ToCoroutine(async() => { clientObjectManager.OnObjectDestroy(new ObjectDestroyMessage { netId = identity.NetId }); await AsyncUtil.WaitUntilWithTimeout(() => identity == null); Assert.That(identity == null); });
public IEnumerator ReadyExceptionTest() => UniTask.ToCoroutine(async() => { sceneManager.Client.Disconnect(); await AsyncUtil.WaitUntilWithTimeout(() => !sceneManager.Client.Active); Assert.Throws <InvalidOperationException>(() => { sceneManager.SetClientReady(); }); });