-
Notifications
You must be signed in to change notification settings - Fork 461
Expand file tree
/
Copy pathNetcodeIntegrationTest.cs
More file actions
2670 lines (2368 loc) · 125 KB
/
NetcodeIntegrationTest.cs
File metadata and controls
2670 lines (2368 loc) · 125 KB
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using NUnit.Framework;
using Unity.Netcode.RuntimeTests;
using Unity.Netcode.Transports.UTP;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
using Object = UnityEngine.Object;
namespace Unity.Netcode.TestHelpers.Runtime
{
/// <summary>
/// The default Netcode for GameObjects integration test helper class
/// </summary>
public abstract class NetcodeIntegrationTest
{
/// <summary>
/// Used to determine if a NetcodeIntegrationTest is currently running to
/// determine how clients will load scenes
/// </summary>
protected const float k_DefaultTimeoutPeriod = 8.0f;
/// <summary>
/// Returns the default tick rate divided into one in order to get the tick frequency.
/// </summary>
protected const float k_TickFrequency = 1.0f / k_DefaultTickRate;
internal static bool IsRunning { get; private set; }
/// <summary>
/// A generic time out helper used with wait conditions.
/// </summary>
protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(k_DefaultTimeoutPeriod);
/// <summary>
/// A generic default <see cref="WaitForSecondsRealtime"/> calculated from the <see cref="k_TickFrequency"/>.
/// </summary>
protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(k_TickFrequency);
/// <summary>
/// Can be used to handle log assertions.
/// </summary>
public NetcodeLogAssert NetcodeLogAssert;
/// <summary>
/// Used with <see cref="ValuesAttribute"/> to describe whether scene management is enabled or disabled.
/// </summary>
public enum SceneManagementState
{
/// <summary>
/// Scene management is enabled.
/// </summary>
SceneManagementEnabled,
/// <summary>
/// Scene management is disabled.
/// </summary>
SceneManagementDisabled
}
private StringBuilder m_InternalErrorLog = new StringBuilder();
internal StringBuilder VerboseDebugLog = new StringBuilder();
/// <summary>
/// Registered list of all NetworkObjects spawned.
/// Format is as follows:
/// [ClientId-side where this NetworkObject instance resides][NetworkObjectId][NetworkObject]
/// Where finding the NetworkObject with a NetworkObjectId of 10 on ClientId of 2 would be:
/// s_GlobalNetworkObjects[2][10]
/// To find the client or server player objects please see:
/// <see cref="m_PlayerNetworkObjects"/>
/// </summary>
protected static Dictionary<ulong, Dictionary<ulong, NetworkObject>> s_GlobalNetworkObjects = new Dictionary<ulong, Dictionary<ulong, NetworkObject>>();
/// <summary>
/// Used by <see cref="ObjectNameIdentifier"/> to register spawned <see cref="NetworkObject"/> instances.
/// </summary>
/// <param name="networkObject">The <see cref="NetworkObject"/> being registered for a test in progress.</param>
public static void RegisterNetworkObject(NetworkObject networkObject)
{
if (!s_GlobalNetworkObjects.ContainsKey(networkObject.NetworkManager.LocalClientId))
{
s_GlobalNetworkObjects.Add(networkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
}
if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].ContainsKey(networkObject.NetworkObjectId))
{
if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId] == null)
{
Assert.False(s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId][networkObject.NetworkObjectId] != null,
$"Duplicate NetworkObjectId {networkObject.NetworkObjectId} found in {nameof(s_GlobalNetworkObjects)} for client id {networkObject.NetworkManager.LocalClientId}!");
}
else
{
s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId][networkObject.NetworkObjectId] = networkObject;
}
}
else
{
s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].Add(networkObject.NetworkObjectId, networkObject);
}
}
/// <summary>
/// Used by <see cref="ObjectNameIdentifier"/> to de-register a spawned <see cref="NetworkObject"/> instance.
/// </summary>
/// <param name="networkObject">The <see cref="NetworkObject"/> being de-registered for a test in progress.</param>
public static void DeregisterNetworkObject(NetworkObject networkObject)
{
if (networkObject.IsSpawned && networkObject.NetworkManager != null)
{
DeregisterNetworkObject(networkObject.NetworkManager.LocalClientId, networkObject.NetworkObjectId);
}
}
/// <summary>
/// Overloaded version of <see cref="DeregisterNetworkObject"/>.<br />
/// Used by <see cref="ObjectNameIdentifier"/> to de-register a spawned <see cref="NetworkObject"/> instance.
/// </summary>
/// <param name="localClientId">The client instance identifier of the spawned <see cref="NetworkObject"/> instance.</param>
/// <param name="networkObjectId">The <see cref="NetworkObject.NetworkObjectId"/> of the spawned instance.</param>
public static void DeregisterNetworkObject(ulong localClientId, ulong networkObjectId)
{
if (s_GlobalNetworkObjects.ContainsKey(localClientId) && s_GlobalNetworkObjects[localClientId].ContainsKey(networkObjectId))
{
s_GlobalNetworkObjects[localClientId].Remove(networkObjectId);
if (s_GlobalNetworkObjects[localClientId].Count == 0)
{
s_GlobalNetworkObjects.Remove(localClientId);
}
}
}
private int GetTotalClients()
{
if (m_DistributedAuthority)
{
// If not connecting to a CMB service then we are using a DAHost and we add 1 to this count.
return !UseCMBService() && m_UseHost ? m_NumberOfClients + 1 : m_NumberOfClients;
}
else
{
// If using a host then we add one to this count.
return m_UseHost ? m_NumberOfClients + 1 : m_NumberOfClients;
}
}
/// <summary>
/// Total number of clients that should be connected at any point during a test.
/// </summary>
/// <remarks>
/// When using the CMB Service, we ignore if <see cref="m_UseHost"/> is true.
/// </remarks>
protected int TotalClients => GetTotalClients();
/// <summary>
/// Defines the default tick rate to use.
/// </summary>
protected const uint k_DefaultTickRate = 30;
/// <summary>
/// Specifies the number of client instances to be created for the integration test.
/// </summary>
/// <remarks>
/// Client-Server network topology:<br />
/// When running as a host the total number of clients will be NumberOfClients + 1.<br />
/// See the calculation for <see cref="TotalClients"/>.
/// Distributed Authority network topology:<br />
/// When connecting to a CMB server, if the <see cref="NumberOfClients"/> == 0 then a session owner client will
/// be automatically added in order to start the session and the private internal m_NumberOfClients value, which
/// is initialized as <see cref="NumberOfClients"/>, will be incremented by 1 making <see cref="TotalClients"/> yield the
/// same results as if we were running a Host where it will effectively be <see cref="NumberOfClients"/>
/// + 1.
/// </remarks>
protected abstract int NumberOfClients { get; }
private int m_NumberOfClients;
/// <summary>
/// Set this to false to create the clients first.<br />
/// Note: If you are using scene placed NetworkObjects or doing any form of scene testing and
/// get prefab hash id "soft synchronization" errors, then set this to false and run your test
/// again. This is a work-around until we can resolve some issues with NetworkManagerOwner and
/// NetworkManager.Singleton.
/// </summary>
protected bool m_CreateServerFirst = true;
/// <summary>
/// Used to define how long <see cref="NetworkManager"/> instances persist between tests or if any should be created at all.
/// </summary>
public enum NetworkManagerInstatiationMode
{
/// <summary>
/// This will create and destroy new NetworkManagers for each test within a child derived class
/// </summary>
PerTest,
/// <summary>
/// This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
/// </summary>
AllTests,
/// <summary>
/// This will not create any NetworkManagers, it is up to the derived class to manage.
/// </summary>
DoNotCreate
}
/// <summary>
/// Typically used with <see cref="TestFixtureAttribute"/> to define what kind of authority <see cref="NetworkManager"/> to use.
/// </summary>
public enum HostOrServer
{
/// <summary>
/// Denotes to use a Host.
/// </summary>
Host,
/// <summary>
/// Denotes to use a Server.
/// </summary>
Server,
/// <summary>
/// Denotes that distributed authority is being used.
/// </summary>
DAHost
}
/// <summary>
/// The default player prefab that is automatically generated and assigned to <see cref="NetworkManager"/> instances. <br />
/// See also: The virtual method <see cref="OnCreatePlayerPrefab"/> that is invoked after the player prefab has been created.
/// </summary>
protected GameObject m_PlayerPrefab;
/// <summary>
/// The Server <see cref="NetworkManager"/> instance instantiated and tracked within the current test
/// </summary>
protected NetworkManager m_ServerNetworkManager;
/// <summary>
/// All the client <see cref="NetworkManager"/> instances instantiated and tracked within the current test
/// </summary>
protected NetworkManager[] m_ClientNetworkManagers;
/// <summary>
/// All the <see cref="NetworkManager"/> instances instantiated and tracked within the current test
/// </summary>
protected NetworkManager[] m_NetworkManagers;
/// <summary>
/// Gets the current authority of the network session.
/// When using the hosted CMB service this will be the client who is the session owner.
/// Otherwise, returns the server <see cref="NetworkManager"/>
/// </summary>
/// <returns>The <see cref="NetworkManager"/> instance that is the current authority</returns>
protected NetworkManager GetAuthorityNetworkManager()
{
if (m_DistributedAuthority)
{
// If we haven't even started any NetworkManager, then return the first instance
// since it will be the session owner.
if (!NetcodeIntegrationTestHelpers.IsStarted)
{
return m_UseCmbService ? m_NetworkManagers[0] : m_ServerNetworkManager;
}
if (!m_UseCmbService && m_ServerNetworkManager.LocalClient.IsSessionOwner)
{
return m_ServerNetworkManager;
}
foreach (var client in m_NetworkManagers)
{
if (client.LocalClient.IsSessionOwner)
{
return client;
}
}
Assert.Fail("No DA session owner found!");
}
return m_ServerNetworkManager;
}
/// <summary>
/// Gets a non-session owner <see cref="NetworkManager"/>.
/// </summary>
/// <returns>A <see cref="NetworkManager"/> instance that will not be the session owner</returns>
protected NetworkManager GetNonAuthorityNetworkManager()
{
// Return the equivalent of m_ClientNetworkManagers[0]
return GetNonAuthorityNetworkManager(0);
}
/// <summary>
/// Gets the non-session owner <see cref="NetworkManager"/> indicated by the passed in index.
/// </summary>
/// <param name="nonAuthorityIndex">Index of the number of the non-authority client wanted</param>
/// <returns>The <see cref="NetworkManager"/> instance that is not the session owner at the given index</returns>
protected NetworkManager GetNonAuthorityNetworkManager(int nonAuthorityIndex)
{
var numSeen = 0;
for (int i = 0; i < m_ClientNetworkManagers.Length; i++)
{
if (i == 0 && !NetcodeIntegrationTestHelpers.IsStarted)
{
continue;
}
if (!m_ClientNetworkManagers[i].LocalClient.IsSessionOwner)
{
if (numSeen == nonAuthorityIndex)
{
return m_ClientNetworkManagers[i];
}
numSeen++;
}
}
Assert.Fail("No valid non-authority network manager found!");
return null;
}
/// <summary>
/// Contains each client relative set of player NetworkObject instances
/// [Client Relative set of player instances][The player instance ClientId][The player instance's NetworkObject]
/// Example:
/// To get the player instance with a ClientId of 3 that was instantiated (relative) on the player instance with a ClientId of 2
/// m_PlayerNetworkObjects[2][3]
/// </summary>
protected Dictionary<ulong, Dictionary<ulong, NetworkObject>> m_PlayerNetworkObjects = new Dictionary<ulong, Dictionary<ulong, NetworkObject>>();
/// <summary>
/// Determines if a host will be used (default is <see cref="true"/>).
/// </summary>
protected bool m_UseHost = true;
/// <summary>
/// Returns <see cref="true"/> if using a distributed authority network topology for the test.
/// </summary>
protected bool m_DistributedAuthority => m_NetworkTopologyType == NetworkTopologyTypes.DistributedAuthority;
/// <summary>
/// The network topology type being used by the test.
/// </summary>
protected NetworkTopologyTypes m_NetworkTopologyType = NetworkTopologyTypes.ClientServer;
/// <summary>
/// Indicates whether the currently running tests are targeting the hosted CMB Service
/// </summary>
/// <remarks>Can only be true if <see cref="UseCMBService"/> returns true.</remarks>
protected bool m_UseCmbService { get; private set; }
private string m_UseCmbServiceEnvString = null;
private bool m_UseCmbServiceEnv;
/// <summary>
/// Will check the environment variable once and then always return the results
/// of the first check.
/// </summary>
/// <remarks>
/// This resets its properties during <see cref="OnOneTimeTearDown"/>, so it will
/// check the environment variable once per test set.
/// </remarks>
/// <returns><see cref="true"/> or <see cref="false"/></returns>
private bool GetServiceEnvironmentVariable()
{
if (!m_UseCmbServiceEnv && m_UseCmbServiceEnvString == null)
{
m_UseCmbServiceEnvString = NetcodeIntegrationTestHelpers.GetCMBServiceEnvironentVariable();
if (bool.TryParse(m_UseCmbServiceEnvString.ToLower(), out bool isTrue))
{
m_UseCmbServiceEnv = isTrue;
}
else
{
Debug.LogWarning($"The USE_CMB_SERVICE ({m_UseCmbServiceEnvString}) value is an invalid bool string. {m_UseCmbService} is being set to false.");
m_UseCmbServiceEnv = false;
}
}
return m_UseCmbServiceEnv;
}
/// <summary>
/// Indicates whether a hosted CMB service is available.
/// </summary>
/// <remarks>Override to return false to ensure a set of tests never runs against the hosted service</remarks>
/// <returns><see cref="true"/> if a DAHost test should run against a hosted CMB service instance; otherwise it returns <see cref="false"/>.</returns>
protected virtual bool UseCMBService()
{
return m_UseCmbService;
}
/// <summary>
/// Override this virtual method to control what kind of <see cref="NetworkTopologyTypes"/> to use.
/// </summary>
/// <returns><see cref="NetworkTopologyTypes"/></returns>
protected virtual NetworkTopologyTypes OnGetNetworkTopologyType()
{
return m_NetworkTopologyType;
}
/// <summary>
/// Can be used to set the distributed authority properties for a test.
/// </summary>
/// <param name="networkManager">The <see cref="NetworkManager"/> to configure.</param>
protected void SetDistributedAuthorityProperties(NetworkManager networkManager)
{
networkManager.NetworkConfig.NetworkTopology = m_NetworkTopologyType;
networkManager.NetworkConfig.AutoSpawnPlayerPrefabClientSide = m_DistributedAuthority;
networkManager.NetworkConfig.UseCMBService = m_UseCmbService;
}
/// <summary>
/// Defines the target frame rate to use during a test.
/// </summary>
protected int m_TargetFrameRate = 60;
private NetworkManagerInstatiationMode m_NetworkManagerInstatiationMode;
/// <summary>
/// Determines if <see cref="VerboseDebug(string)"/> will generate a console log message.
/// </summary>
protected bool m_EnableVerboseDebug { get; set; }
/// <summary>
/// When set to true, this will bypass the entire
/// wait for clients to connect process.
/// </summary>
/// <remarks>
/// CAUTION:
/// Setting this to true will bypass other helper
/// identification related code, so this should only
/// be used for connection failure oriented testing
/// </remarks>
protected bool m_BypassConnectionTimeout { get; set; }
/// <summary>
/// Enables "Time Travel" within the test, which swaps the time provider for the SDK from Unity's
/// <see cref="Time"/> class to <see cref="MockTimeProvider"/>, and also swaps the transport implementation
/// from <see cref="UnityTransport"/> to <see cref="MockTransport"/>.
///
/// This enables five important things that help with both performance and determinism of tests that involve a
/// lot of time and waiting:
/// 1) It allows time to move in a completely deterministic way (testing that something happens after n seconds,
/// the test will always move exactly n seconds with no chance of any variability in the timing),
/// 2) It allows skipping periods of time without actually waiting that amount of time, while still simulating
/// SDK frames as if that time were passing,
/// 3) It dissociates the SDK's update loop from Unity's update loop, allowing us to simulate SDK frame updates
/// without waiting for Unity to process things like physics, animation, and rendering that aren't relevant to
/// the test,
/// 4) It dissociates the SDK's messaging system from the networking hardware, meaning there's no delay between
/// a message being sent and it being received, allowing us to deterministically rely on the message being
/// received within specific time frames for the test, and
/// 5) It allows tests to be written without the use of coroutines, which not only improves the test's runtime,
/// but also results in easier-to-read callstacks and removes the possibility for an assertion to result in the
/// test hanging.
///
/// When time travel is enabled, the following methods become available:
///
/// <see cref="TimeTravel"/>: Simulates a specific number of frames passing over a specific time period
/// <see cref="TimeTravelToNextTick"/>: Skips forward to the next tick, siumlating at the current application frame rate
/// <see cref="WaitForConditionOrTimeOutWithTimeTravel(Func{bool},int)"/>: Simulates frames at the application frame rate until the given condition is true
/// <see cref="WaitForMessageReceivedWithTimeTravel{T}"/>: Simulates frames at the application frame rate until the required message is received
/// <see cref="WaitForMessagesReceivedWithTimeTravel"/>: Simulates frames at the application frame rate until the required messages are received
/// <see cref="StartServerAndClientsWithTimeTravel"/>: Starts a server and client and allows them to connect via simulated frames
/// <see cref="CreateAndStartNewClientWithTimeTravel"/>: Creates a client and waits for it to connect via simulated frames
/// <see cref="WaitForClientsConnectedOrTimeOutWithTimeTravel(Unity.Netcode.NetworkManager[])"/> Simulates frames at the application frame rate until the given clients are connected
/// <see cref="StopOneClientWithTimeTravel"/>: Stops a client and simulates frames until it's fully disconnected.
///
/// When time travel is enabled, <see cref="NetcodeIntegrationTest"/> will automatically use these in its methods
/// when doing things like automatically connecting clients during SetUp.
///
/// Additionally, the following methods replace their non-time-travel equivalents with variants that are not coroutines:
/// <see cref="OnTimeTravelStartedServerAndClients"/> - called when server and clients are started
/// <see cref="OnTimeTravelServerAndClientsConnected"/> - called when server and clients are connected
///
/// Note that all of the non-time travel functions can still be used even when time travel is enabled - this is
/// sometimes needed for, e.g., testing NetworkAnimator, where the unity update loop needs to run to process animations.
/// However, it's VERY important to note here that, because the SDK will not be operating based on real-world time
/// but based on the frozen time that's locked in from MockTimeProvider, actions that pass 10 seconds apart by
/// real-world clock time will be perceived by the SDK as having happened simultaneously if you don't call
/// <see cref="MockTimeProvider.TimeTravel"/> to cover the equivalent time span in the mock time provider.
/// (Calling <see cref="MockTimeProvider.TimeTravel"/> instead of <see cref="TimeTravel"/>
/// will move time forward without simulating any frames, which, in the case where real-world time has passed,
/// is likely more desirable). In most cases, this desynch won't affect anything, but it is worth noting that
/// it happens just in case a tested system depends on both the unity update loop happening *and* time moving forward.
/// </summary>
protected virtual bool m_EnableTimeTravel => false;
/// <summary>
/// When true, <see cref="CreateServerAndClients()"/> and <see cref="CreateNewClient"/> will use a <see cref="MockTransport"/>
/// as the <see cref="NetworkConfig.NetworkTransport"/> on the created server and/or clients.
/// When false, a <see cref="UnityTransport"/> is used.
/// </summary>
/// <remarks>
/// This defaults to, and is required to be true when <see cref="m_EnableTimeTravel"/> is true.
/// <see cref="m_EnableTimeTravel"/> will not work with the <see cref="UnityTransport"/> component.
/// </remarks>
protected virtual bool m_UseMockTransport => m_EnableTimeTravel;
/// <summary>
/// If this is false, SetUp will call OnInlineSetUp instead of OnSetUp.
/// This is a performance advantage when not using the coroutine functionality, as a coroutine that
/// has no yield instructions in it will nonetheless still result in delaying the continuation of the
/// method that called it for a full frame after it returns.
/// </summary>
protected virtual bool m_SetupIsACoroutine => true;
/// <summary>
/// If this is false, TearDown will call OnInlineTearDown instead of OnTearDown.
/// This is a performance advantage when not using the coroutine functionality, as a coroutine that
/// has no yield instructions in it will nonetheless still result in delaying the continuation of the
/// method that called it for a full frame after it returns.
/// </summary>
protected virtual bool m_TearDownIsACoroutine => true;
/// <summary>
/// Used to display the various integration test
/// stages and can be used to log verbose information
/// for troubleshooting an integration test.
/// </summary>
/// <param name="msg">The debug message to be logged when verbose debugging is enabled</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected void VerboseDebug(string msg)
{
if (m_EnableVerboseDebug)
{
VerboseDebugLog.AppendLine(msg);
Debug.Log(msg);
}
}
/// <summary>
/// Override this and return true if you need
/// to troubleshoot a hard to track bug within an
/// integration test.
/// </summary>
/// <returns><see cref="true"/> or <see cref="false"/></returns>
protected virtual bool OnSetVerboseDebug()
{
return false;
}
/// <summary>
/// The very first thing invoked during the <see cref="OneTimeSetup"/> that
/// determines how this integration test handles NetworkManager instantiation
/// and destruction. <see cref="NetworkManagerInstatiationMode"/>
/// Override this method to change the default mode:
/// <see cref="NetworkManagerInstatiationMode.AllTests"/>
/// </summary>
/// <returns><see cref="NetworkManagerInstatiationMode"/></returns>
protected virtual NetworkManagerInstatiationMode OnSetIntegrationTestMode()
{
return NetworkManagerInstatiationMode.PerTest;
}
/// <summary>
/// Override this method to do any one time setup configurations.
/// </summary>
protected virtual void OnOneTimeSetup()
{
}
/// <summary>
/// The <see cref="OneTimeSetUpAttribute"/> decorated method that is invoked once per derived <see cref="NetcodeIntegrationTest"/> instance.
/// </summary>
[OneTimeSetUp]
public void OneTimeSetup()
{
// Only For CMB Server Tests:
// If the environment variable is set (i.e. doing a CMB server run) but UseCMBservice returns false, then ignore the test.
// Note: This will prevent us from re-running all of the non-DA integration tests that have already run multiple times on
// multiple platforms
if (GetServiceEnvironmentVariable() && !UseCMBService())
{
Assert.Ignore("[CMB-Server Test Run] Skipping non-distributed authority test.");
return;
}
else
{
// Otherwise, continue with the test
InternalOnOneTimeSetup();
}
}
private void InternalOnOneTimeSetup()
{
Application.runInBackground = true;
m_NumberOfClients = NumberOfClients;
IsRunning = true;
m_EnableVerboseDebug = OnSetVerboseDebug();
IntegrationTestSceneHandler.VerboseDebugMode = m_EnableVerboseDebug;
NetworkManagerHelper.VerboseDebugMode = m_EnableVerboseDebug;
VerboseDebug($"Entering {nameof(OneTimeSetup)}");
m_NetworkManagerInstatiationMode = OnSetIntegrationTestMode();
// Enable NetcodeIntegrationTest auto-label feature
NetcodeIntegrationTestHelpers.RegisterNetcodeIntegrationTest(true);
#if UNITY_INCLUDE_TESTS
// Provide an external hook to be able to make adjustments to netcode classes prior to running any tests
NetworkManager.OnOneTimeSetup();
#endif
OnOneTimeSetup();
VerboseDebug($"Exiting {nameof(OneTimeSetup)}");
#if DEVELOPMENT_BUILD || UNITY_EDITOR
// Default to not log the serialized type not optimized warning message when testing.
NetworkManager.DisableNotOptimizedSerializedType = true;
#endif
}
/// <summary>
/// Called before creating and starting the server and clients
/// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and
/// <see cref="NetworkManagerInstatiationMode.PerTest"/> mode integration tests.
/// For those two modes, if you want to have access to the server or client
/// <see cref="NetworkManager"/>s then override <see cref="OnServerAndClientsCreated"/>.
/// <see cref="m_ServerNetworkManager"/> and <see cref="m_ClientNetworkManagers"/>
/// </summary>
/// <returns><see cref="IEnumerator"/></returns>
protected virtual IEnumerator OnSetup()
{
yield return null;
}
/// <summary>
/// Called before creating and starting the server and clients
/// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and
/// <see cref="NetworkManagerInstatiationMode.PerTest"/> mode integration tests.
/// For those two modes, if you want to have access to the server or client
/// <see cref="NetworkManager"/>s then override <see cref="OnServerAndClientsCreated"/>.
/// <see cref="m_ServerNetworkManager"/> and <see cref="m_ClientNetworkManagers"/>
/// </summary>
protected virtual void OnInlineSetup()
{
}
/// <summary>
/// The <see cref="UnitySetUpAttribute"/> decorated method that is invoked once per <see cref="TestFixtureAttribute"/> instance or just once if none.
/// </summary>
/// <returns><see cref="IEnumerator"/></returns>
[UnitySetUp]
public IEnumerator SetUp()
{
// In addition to setting the number of clients in the OneTimeSetup, we need to re-apply the number of clients for each unique test
// in the event that a previous test stopped a client.
m_NumberOfClients = NumberOfClients;
VerboseDebugLog.Clear();
VerboseDebug($"Entering {nameof(SetUp)}");
NetcodeLogAssert = new NetcodeLogAssert();
if (m_UseMockTransport)
{
if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests)
{
MockTransport.ClearQueues();
}
else
{
MockTransport.Reset();
}
}
// Setup the frames per tick for time travel advance to next tick
if (m_EnableTimeTravel)
{
ConfigureFramesPerTick();
}
if (m_SetupIsACoroutine)
{
yield return OnSetup();
}
else
{
OnInlineSetup();
}
if (m_EnableTimeTravel)
{
MockTimeProvider.Reset();
ComponentFactory.Register<IRealTimeProvider>(manager => new MockTimeProvider());
}
if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests && !NetcodeIntegrationTestHelpers.IsStarted ||
m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
{
CreateServerAndClients();
if (m_EnableTimeTravel)
{
StartServerAndClientsWithTimeTravel();
}
else
{
yield return StartServerAndClients();
}
}
VerboseDebug($"Exiting {nameof(SetUp)}");
}
/// <summary>
/// Override this to add components or adjustments to the default player prefab
/// <see cref="m_PlayerPrefab"/>
/// </summary>
protected virtual void OnCreatePlayerPrefab()
{
}
/// <summary>
/// Invoked immediately after the player prefab GameObject is created
/// prior to adding a NetworkObject component
/// </summary>
protected virtual void OnPlayerPrefabGameObjectCreated()
{
}
private void CreatePlayerPrefab()
{
VerboseDebug($"Entering {nameof(CreatePlayerPrefab)}");
// Create playerPrefab
m_PlayerPrefab = new GameObject("Player");
OnPlayerPrefabGameObjectCreated();
NetworkObject networkObject = m_PlayerPrefab.AddComponent<NetworkObject>();
networkObject.IsSceneObject = false;
// Make it a prefab
NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
OnCreatePlayerPrefab();
VerboseDebug($"Exiting {nameof(CreatePlayerPrefab)}");
}
private void AddRemoveNetworkManager(NetworkManager networkManager, bool addNetworkManager)
{
var clientNetworkManagersList = new List<NetworkManager>(m_ClientNetworkManagers);
if (addNetworkManager)
{
clientNetworkManagersList.Add(networkManager);
}
else
{
clientNetworkManagersList.Remove(networkManager);
}
m_ClientNetworkManagers = clientNetworkManagersList.ToArray();
m_NumberOfClients = clientNetworkManagersList.Count;
if (!m_UseCmbService)
{
clientNetworkManagersList.Insert(0, m_ServerNetworkManager);
}
m_NetworkManagers = clientNetworkManagersList.ToArray();
}
/// <summary>
/// This is invoked before the server and client(s) are started.
/// Override this method if you want to make any adjustments to their
/// NetworkManager instances.
/// </summary>
protected virtual void OnServerAndClientsCreated()
{
}
/// <summary>
/// Will create <see cref="NumberOfClients"/> number of clients.
/// To create a specific number of clients <see cref="CreateServerAndClients(int)"/>
/// </summary>
protected void CreateServerAndClients()
{
CreateServerAndClients(NumberOfClients);
}
/// <summary>
/// Creates the server and clients
/// </summary>
/// <param name="numberOfClients">The number of client instances to create</param>
protected void CreateServerAndClients(int numberOfClients)
{
VerboseDebug($"Entering {nameof(CreateServerAndClients)}");
CreatePlayerPrefab();
if (m_EnableTimeTravel)
{
m_TargetFrameRate = -1;
}
// If we are connecting to a CMB server we add +1 for the session owner
if (m_UseCmbService)
{
numberOfClients++;
}
// Create multiple NetworkManager instances
if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_UseMockTransport, m_UseCmbService))
{
Debug.LogError("Failed to create instances");
Assert.Fail("Failed to create instances");
}
m_NumberOfClients = numberOfClients;
m_ClientNetworkManagers = clients;
m_ServerNetworkManager = server;
NetworkLog.ConfigureIntegrationTestLogging(server, m_EnableVerboseDebug);
var managers = clients.ToList();
if (!m_UseCmbService)
{
managers.Insert(0, m_ServerNetworkManager);
}
m_NetworkManagers = managers.ToArray();
s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / GetAuthorityNetworkManager().NetworkConfig.TickRate);
// Set the player prefab for the server and clients
foreach (var manager in m_NetworkManagers)
{
manager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(manager);
}
// Provides opportunity to allow child derived classes to
// modify the NetworkManager's configuration before starting.
OnServerAndClientsCreated();
VerboseDebug($"Exiting {nameof(CreateServerAndClients)}");
}
/// <summary>
/// CreateAndStartNewClient Only
/// Invoked when the newly created client has been created
/// </summary>
/// <param name="networkManager">The NetworkManager instance of the client.</param>
protected virtual void OnNewClientCreated(NetworkManager networkManager)
{
// Ensure any late joining client has all NetworkPrefabs required to connect.
var authority = GetAuthorityNetworkManager();
networkManager.NetworkConfig.EnableSceneManagement = authority.NetworkConfig.EnableSceneManagement;
foreach (var networkPrefab in authority.NetworkConfig.Prefabs.Prefabs)
{
if (!networkManager.NetworkConfig.Prefabs.Contains(networkPrefab.Prefab))
{
networkManager.NetworkConfig.Prefabs.Add(networkPrefab);
}
}
}
/// <summary>
/// CreateAndStartNewClient Only
/// Invoked when the newly created client has been created and started
/// </summary>
/// <param name="networkManager">The NetworkManager instance of the client.</param>
protected virtual void OnNewClientStarted(NetworkManager networkManager)
{
}
/// <summary>
/// CreateAndStartNewClient Only
/// Invoked when the newly created client has been created, started, and connected
/// to the server-host.
/// </summary>
/// <param name="networkManager">The NetworkManager instance of the client.</param>
protected virtual void OnNewClientStartedAndConnected(NetworkManager networkManager)
{
}
/// <summary>
/// CreateAndStartNewClient Only
/// Override this method to bypass the waiting for a client to connect.
/// </summary>
/// <remarks>
/// Use this for testing connection and disconnection scenarios
/// </remarks>
/// <param name="networkManager">The NetworkManager instance of the client.</param>
/// <returns><see cref="true"/> if the test should wait for the client to connect; otherwise, it returns <see cref="false"/>.</returns>
protected virtual bool ShouldWaitForNewClientToConnect(NetworkManager networkManager)
{
return true;
}
/// <summary>
/// This will create a new client while in the middle of an integration test.
/// Use <see cref="StartClient"/> to start the created client.
/// </summary>
/// <returns>The newly created <see cref="NetworkManager"/>.</returns>
protected NetworkManager CreateNewClient()
{
var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_UseMockTransport, m_UseCmbService);
networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
SetDistributedAuthorityProperties(networkManager);
// Notification that the new client (NetworkManager) has been created
// in the event any modifications need to be made before starting the client
OnNewClientCreated(networkManager);
return networkManager;
}
/// <summary>
/// This will create, start, and connect a new client while in the middle of an
/// integration test.
/// </summary>
/// <returns>An <see cref="IEnumerator"/> to be used in a coroutine for asynchronous execution.</returns>
protected IEnumerator CreateAndStartNewClient()
{
var networkManager = CreateNewClient();
yield return StartClient(networkManager);
}
/// <summary>
/// Starts and connects the given networkManager as a client while in the middle of an
/// integration test.
/// </summary>
/// <param name="networkManager">The network manager to start and connect</param>
/// <returns>An <see cref="IEnumerator"/> to be used in a coroutine for asynchronous execution.</returns>
protected IEnumerator StartClient(NetworkManager networkManager)
{
NetcodeIntegrationTestHelpers.StartOneClient(networkManager);
if (LogAllMessages)
{
networkManager.ConnectionManager.MessageManager.Hook(new DebugNetworkHooks());
}
AddRemoveNetworkManager(networkManager, true);
OnNewClientStarted(networkManager);
if (ShouldWaitForNewClientToConnect(networkManager))
{
// Wait for the new client to connect
yield return WaitForClientsConnectedOrTimeOut();
if (s_GlobalTimeoutHelper.TimedOut)
{
AddRemoveNetworkManager(networkManager, false);
Object.DestroyImmediate(networkManager.gameObject);
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!\n {m_InternalErrorLog}");
yield break;
}
else
{
OnNewClientStartedAndConnected(networkManager);
}
ClientNetworkManagerPostStart(networkManager);
if (networkManager.DistributedAuthorityMode)
{
yield return WaitForConditionOrTimeOut(() => AllPlayerObjectClonesSpawned(networkManager));
AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for all sessions to spawn Client-{networkManager.LocalClientId}'s player object!");
}
VerboseDebug($"[{networkManager.name}] Created and connected!");
}
}
private bool AllPlayerObjectClonesSpawned(NetworkManager joinedClient)
{
m_InternalErrorLog.Clear();
// If we are not checking for spawned players then exit early with a success
if (!ShouldCheckForSpawnedPlayers())
{
return true;
}
// Continue to populate the PlayerObjects list until all player object (local and clone) are found
ClientNetworkManagerPostStart(joinedClient);
foreach (var networkManager in m_NetworkManagers)
{
if (networkManager.LocalClientId == joinedClient.LocalClientId)
{
continue;
}
var playerObjectRelative = networkManager.SpawnManager.PlayerObjects.FirstOrDefault(c => c.OwnerClientId == joinedClient.LocalClientId);
if (playerObjectRelative == null)
{
m_InternalErrorLog.Append($"[AllPlayerObjectClonesSpawned][Client-{networkManager.LocalClientId}] Client-{joinedClient.LocalClientId} was not populated in the {nameof(NetworkSpawnManager.PlayerObjects)} list!");
return false;
}
if (playerObjectRelative.Observers.Count != m_NetworkManagers.Length)
{
m_InternalErrorLog.Append($"Client-{networkManager.LocalClientId} has an incorrect number of observers for Object-{playerObjectRelative.NetworkObjectId}!");
return false;
}
// Go ahead and create an entry for this new client
if (!m_PlayerNetworkObjects[networkManager.LocalClientId].ContainsKey(joinedClient.LocalClientId))
{
m_PlayerNetworkObjects[networkManager.LocalClientId].Add(joinedClient.LocalClientId, playerObjectRelative);
}
}