com.unity.netcode.gameobjects/testproject/Assets/Tests/Runtime/SenderIdTests.cs at 00a4731b38eb19c87e952420ab3886653fa4813f · Unity-Technologies/com.unity.netcode.gameobjects · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using Unity.Collections;
using Unity.Netcode;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;

namespace TestProject.RuntimeTests
{
    public class SenderIdTests : NetcodeIntegrationTest
    {
        protected override int NumberOfClients => 2;

        private NetworkManager FirstClient => m_ClientNetworkManagers[0];
        private NetworkManager SecondClient => m_ClientNetworkManagers[1];

        [UnityTest]
        public IEnumerator WhenSendingMessageFromServerToClient_SenderIdIsCorrect()
        {
            var messageContent = new ForceNetworkSerializeByMemcpy<Guid> { Value = Guid.NewGuid() };
            var writer = new FastBufferWriter(1300, Allocator.Temp);
            using (writer)
            {
                writer.WriteValueSafe(messageContent);
                m_ServerNetworkManager.CustomMessagingManager.SendUnnamedMessageToAll(writer);
            }

            bool firstReceived = false;
            FirstClient.CustomMessagingManager.OnUnnamedMessage +=
                (sender, reader) =>
                {
                    firstReceived = true;
                    Assert.AreEqual(sender, NetworkManager.ServerClientId);
                    Assert.AreNotEqual(sender, FirstClient.LocalClientId);
                };

            bool secondReceived = false;
            SecondClient.CustomMessagingManager.OnUnnamedMessage +=
                (sender, reader) =>
                {
                    secondReceived = true;
                    Assert.AreEqual(sender, NetworkManager.ServerClientId);
                    Assert.AreNotEqual(sender, FirstClient.LocalClientId);
                };

            yield return new WaitForSeconds(0.2f);

            Assert.IsTrue(firstReceived);
            Assert.IsTrue(secondReceived);
        }
        [UnityTest]
        public IEnumerator WhenSendingMessageFromClientToServer_SenderIdIsCorrect()
        {
            var writer = new FastBufferWriter(1300, Allocator.Temp);
            using (writer)
            {
                FirstClient.CustomMessagingManager.SendNamedMessage("FirstClient", NetworkManager.ServerClientId, writer);
                SecondClient.CustomMessagingManager.SendNamedMessage("SecondClient", NetworkManager.ServerClientId, writer);

            }

            bool firstReceived = false;
            m_ServerNetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(
                "FirstClient",
                (sender, reader) =>
                {
                    firstReceived = true;
                    Assert.AreEqual(sender, FirstClient.LocalClientId);
                    Assert.AreNotEqual(sender, SecondClient.LocalClientId);
                    Assert.AreNotEqual(sender, m_ServerNetworkManager.LocalClientId);
                });

            bool secondReceived = false;
            m_ServerNetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(
                "SecondClient",
                (sender, reader) =>
                {
                    secondReceived = true;
                    Assert.AreNotEqual(sender, FirstClient.LocalClientId);
                    Assert.AreEqual(sender, SecondClient.LocalClientId);
                    Assert.AreNotEqual(sender, m_ServerNetworkManager.LocalClientId);
                });

            yield return new WaitForSeconds(0.2f);

            Assert.IsTrue(firstReceived);
            Assert.IsTrue(secondReceived);
        }


        private List<ulong> m_ClientsDisconnected = new List<ulong>();
        private ulong m_ClientToValidateDisconnected;

        private bool ValidateClientId()
        {
            return m_ClientsDisconnected.Contains(m_ClientToValidateDisconnected);
        }

        private void OnClientDisconnected(ulong clientId)
        {
            m_ClientsDisconnected.Add(clientId);
        }

        [UnityTest]
        public IEnumerator WhenClientDisconnectsFromServer_ClientIdIsCorrect()
        {
            m_ClientsDisconnected.Clear();
            m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnected;
            m_ClientToValidateDisconnected = m_ClientNetworkManagers[0].LocalClientId;
            FirstClient.Shutdown();
            yield return WaitForConditionOrTimeOut(ValidateClientId);
            AssertOnTimeout($"Timed out waiting for the server to receive Client-{m_ClientToValidateDisconnected} disconnect event!");

            m_ClientToValidateDisconnected = m_ClientNetworkManagers[1].LocalClientId;
            SecondClient.Shutdown();
            yield return WaitForConditionOrTimeOut(ValidateClientId);
            AssertOnTimeout($"Timed out waiting for the server to receive Client-{m_ClientToValidateDisconnected} disconnect event!");
        }
    }
}