Пример #1
0
        public void WatchGameServer_Event_Subscribes()
        {
            var mockSdk = new AgonesSDK();
            Action <GameServer> expected = (gs) => { };

            mockSdk.isWatchingGameServer = true;
            mockSdk.WatchGameServer(expected);

            var result = mockSdk.GameServerUpdatedCallbacks[0];

            Assert.AreSame(expected, result);
        }
Пример #2
0
        public async Task Reserve_Returns_OK()
        {
            var mockClient = new Mock <SDK.SDKClient>();
            var mockSdk    = new AgonesSDK();
            var expected   = StatusCode.OK;
            var fakeCall   = TestCalls.AsyncUnaryCall(Task.FromResult(new Empty()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.ReserveAsync(It.IsAny <Duration>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall);
            mockSdk.client = mockClient.Object;

            var result = await mockSdk.ReserveAsync(30);

            Assert.AreEqual(expected, result.StatusCode);
        }
Пример #3
0
        public async Task GetGameServer_Returns_OK()
        {
            var mockClient = new Mock <SDK.SDKClient>();
            var mockSdk    = new AgonesSDK();
            var expected   = new GameServer();
            var fakeCall   = TestCalls.AsyncUnaryCall(Task.FromResult(expected), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.GetGameServerAsync(It.IsAny <Empty>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall);
            mockSdk.client = mockClient.Object;

            var result = await mockSdk.GetGameServerAsync();

            Assert.AreSame(expected, result);
        }
Пример #4
0
        public async Task PlayerDisconnect_Sends_OK()
        {
            var mockClient = new Mock <SDK.SDKClient>();
            var mockSdk    = new AgonesSDK();
            var expected   = new Bool()
            {
                Bool_ = true
            };
            var fakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(expected), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.PlayerDisconnectAsync(It.IsAny <PlayerID>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall);
            mockSdk.alpha.client = mockClient.Object;

            var result = await mockSdk.Alpha().PlayerDisconnectAsync("test");

            Assert.AreEqual(expected.Bool_, result);
        }
Пример #5
0
        public async Task GetPlayerCapacity_Sends_OK()
        {
            var mockClient = new Mock <SDK.SDKClient>();
            var mockSdk    = new AgonesSDK();
            var expected   = new Count()
            {
                Count_ = 1
            };
            var fakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(expected), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.GetPlayerCapacityAsync(It.IsAny <Empty>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall);
            mockSdk.alpha.client = mockClient.Object;

            var result = await mockSdk.Alpha().GetPlayerCapacityAsync();

            Assert.AreEqual(expected.Count_, result);
        }
Пример #6
0
        public async Task SetLabel_Sends_OK()
        {
            var      mockClient       = new Mock <SDK.SDKClient>();
            var      mockSdk          = new AgonesSDK();
            var      fakeCall         = TestCalls.AsyncUnaryCall(Task.FromResult(new Empty()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
            KeyValue expectedKeyValue = new KeyValue();

            expectedKeyValue.Key   = "Test";
            expectedKeyValue.Value = "Test";
            KeyValue actualKeyValue = null;

            mockClient.Setup(m => m.SetLabelAsync(It.IsAny <KeyValue>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall)
            .Callback(
                (KeyValue kv, Metadata md, DateTime? dt, CancellationToken ct) => { actualKeyValue = kv; });
            mockSdk.client = mockClient.Object;

            var result = await mockSdk.SetLabelAsync(expectedKeyValue.Key, expectedKeyValue.Value);

            Assert.AreEqual(expectedKeyValue, actualKeyValue);
        }
Пример #7
0
        public void WatchGameServer_Returns_OK()
        {
            var        mockClient          = new Mock <SDK.SDKClient>();
            var        mockResponseStream  = new Moq.Mock <IAsyncStreamReader <GameServer> >();
            var        mockSdk             = new AgonesSDK();
            var        expectedWatchReturn = new GameServer();
            GameServer actualWatchReturn   = null;
            var        serverStream        = TestCalls.AsyncServerStreamingCall <GameServer>(mockResponseStream.Object, Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.WatchGameServer(It.IsAny <Empty>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(serverStream);
            mockResponseStream.Setup(m => m.Current).Returns(expectedWatchReturn);
            mockResponseStream.SetupSequence(m => m.MoveNext(It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(true))
            .Returns(Task.FromResult(false));
            mockSdk.client = mockClient.Object;

            mockSdk.WatchGameServer((gs) => { actualWatchReturn = gs; });

            Assert.AreSame(expectedWatchReturn, actualWatchReturn);
        }
Пример #8
0
        public async Task GetConnectedPlayers_Sends_OK()
        {
            var mockClient = new Mock <SDK.SDKClient>();
            var mockSdk    = new AgonesSDK();
            var expected   = new List <string> {
                "player1", "player2"
            };
            var playerList = new PlayerIDList()
            {
                List = { expected }
            };
            var fakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(playerList), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });

            mockClient.Setup(m => m.GetConnectedPlayersAsync(It.IsAny <Empty>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall);
            mockSdk.alpha.client = mockClient.Object;

            var result = await mockSdk.Alpha().GetConnectedPlayersAsync();

            CollectionAssert.AreEquivalent(expected, result);
        }
Пример #9
0
        public async Task Reserve_Sends_OK()
        {
            var mockClient       = new Mock <SDK.SDKClient>();
            var mockSdk          = new AgonesSDK();
            var fakeCall         = TestCalls.AsyncUnaryCall(Task.FromResult(new Empty()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
            var expectedDuration = new Duration();

            expectedDuration.Seconds = 30;
            Duration actualDuration = null;

            mockClient.Setup(m => m.ReserveAsync(It.IsAny <Duration>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>())).Returns(fakeCall)
            .Callback(
                (Duration dur, Metadata md, DateTime? dt, CancellationToken ct) => {
                actualDuration = dur;
            });
            mockSdk.client = mockClient.Object;

            var result = await mockSdk.ReserveAsync(30);

            Assert.AreEqual(expectedDuration, actualDuration);
        }