public void ExecuteUnaryCall_WhenItMapped_ShouldUpdateResponseMarkup() { // Arrange const string ExpectedMessage = "Unusual Markup Message Unary Call"; var clientMock = new Mock <TestService.TestServiceClient>(); clientMock.Setup(m => m.UnaryCallAsync(It.IsAny <HelloRequest>(), It.IsAny <CallOptions>())) .Returns(TestCalls.AsyncUnaryCall( Task.FromResult(new HelloResponse { Message = ExpectedMessage }), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); host.AddService(clientMock.Object); var component = host.AddComponent <TestWrapper>(); // Act component.Find("button.execute.unaryCall").Click(); host.WaitForNextRender(); var markup = component.GetMarkup(); // Assert Assert.Contains(ExpectedMessage, markup); }
private AsyncUnaryCall <TResponse> MockAsyncUnaryCall <TResponse>(TResponse reply) where TResponse : new() { var call = TestCalls.AsyncUnaryCall(Task.FromResult(reply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); return(call); }
public async Task AndUserDoesNotExist_NullIsReturnedAsync() { var loggerMock = Mock.Of <ILogger <AccountManagerService> >(); var clientFactoryMock = new Mock <IClientFactory>(); var clientMock = new Moq.Mock <ResourceAccess.ResourceAccessClient>(); var expectedResponse = new GetUserOnUserNameResponse { User = null }; var fakeCall = TestCalls.AsyncUnaryCall <GetUserOnUserNameResponse>(Task.FromResult(new GetUserOnUserNameResponse()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); clientMock.Setup(m => m.GetUserOnUserNameAsync(Moq.It.IsAny <GetUserOnUserNameRequest>(), null, null, CancellationToken.None)).Returns(fakeCall); clientFactoryMock.Setup(c => c.AccountResourceAccessClient()).Returns(clientMock.Object); var appConfig = Mock.Of <IOptions <AppSettings> >(); var service = new AccountManagerService(loggerMock, clientFactoryMock.Object, appConfig); AuthenticateResponse authResponse = await service.Authenticate(new AuthenticateRequest { HashedPassword = "******", IpAddress = "123", UserName = "******" }, null); Assert.True(string.IsNullOrEmpty(authResponse.JwtToken)); Assert.True(string.IsNullOrEmpty(authResponse.RefreshToken)); Assert.True(string.IsNullOrEmpty(authResponse.Role)); Assert.True(string.IsNullOrEmpty(authResponse.UserId)); Assert.True(string.IsNullOrEmpty(authResponse.UserName)); }
public async Task ToAuthenticateAndUserExist_TokenIsReturnedAsync() { var loggerMock = Mock.Of <ILogger <AccountManagerService> >(); var clientFactoryMock = new Mock <IClientFactory>(); var clientMock = new Moq.Mock <ResourceAccess.ResourceAccessClient>(); var expectedResponse = new GetUserOnUserNameResponse { User = new UserMessage { Firstname = "Firstname", Lastname = "Lastname", UserId = Guid.NewGuid().ToString(), Role = "User", UserName = "******", } }; var fakeCall = TestCalls.AsyncUnaryCall <GetUserOnUserNameResponse>(Task.FromResult(expectedResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); clientMock.Setup(m => m.GetUserOnUserNameAsync(Moq.It.IsAny <GetUserOnUserNameRequest>(), null, null, CancellationToken.None)).Returns(fakeCall); var expectedUpdateResponse = new UpdateUserResponse { User = new UserMessage { Firstname = "Firstname", Lastname = "Lastname", UserId = Guid.NewGuid().ToString(), Role = "User", UserName = "******" } }; expectedUpdateResponse.User.RefreshTokens.Add(new RefreshTokenMessage { CreatedByIp = "123", Token = "123123", }); var fakeUIpdateCall = TestCalls.AsyncUnaryCall <UpdateUserResponse>(Task.FromResult(expectedUpdateResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); clientMock.Setup(m => m.UpdateUserAsync(Moq.It.IsAny <UpdateUserRequest>(), null, null, CancellationToken.None)).Returns(fakeUIpdateCall); clientFactoryMock.Setup(c => c.AccountResourceAccessClient()).Returns(clientMock.Object); var testoption = Options.Create(new AppSettings { SecretString = "secretStuff!ddddddddddddddddddddddddddddddddddddddddddddddddddddddgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg" }); var service = new AccountManagerService(loggerMock, clientFactoryMock.Object, testoption); AuthenticateResponse authResponse = await service.Authenticate(new AuthenticateRequest { HashedPassword = "******", IpAddress = "123", UserName = "******" }, null); Assert.False(string.IsNullOrEmpty(authResponse.JwtToken)); Assert.False(string.IsNullOrEmpty(authResponse.RefreshToken)); Assert.False(string.IsNullOrEmpty(authResponse.Role)); Assert.False(string.IsNullOrEmpty(authResponse.UserId)); Assert.False(string.IsNullOrEmpty(authResponse.UserName)); }
public override AsyncUnaryCall <RunningParameter> GetRunningParameterAsync(GetRunningParameterRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { return(TestCalls.AsyncUnaryCall( Task.FromResult(RunningParameters[request.DeviceId]), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public void ClientBaseAsyncUnaryCallCanBeMocked() { var mockClient = new Moq.Mock <Math.MathClient>(); // Use a factory method provided by Grpc.Core.Testing.TestCalls to create an instance of a call. var fakeCall = TestCalls.AsyncUnaryCall <DivReply>(Task.FromResult(new DivReply()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); mockClient.Setup(m => m.DivAsync(Moq.It.IsAny <DivArgs>(), null, null, CancellationToken.None)).Returns(fakeCall); Assert.AreSame(fakeCall, mockClient.Object.DivAsync(new DivArgs())); }
public override AsyncUnaryCall <Switch> GetSwitchAsync(GetSwitchRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { Switch switchInfo = Switches[request.DeviceId]; return(TestCalls.AsyncUnaryCall( Task.FromResult(switchInfo.Clone()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public static AsyncUnaryCall <TResponse> AsyncUnaryCall <TResponse>( Task <TResponse> responseAsync, Task <Metadata> responseHeadersAsync = null, Func <Status> getStatusFunc = null, Func <Metadata> getTrailersFunc = null, Action disposeAction = null) { return(TestCalls.AsyncUnaryCall( responseAsync, responseHeadersAsync, getStatusFunc, getTrailersFunc, disposeAction)); }
public void Test1() { var mockClient = new Moq.Mock <ProductInfoClient>(); var fakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(new ProductID()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); mockClient.Setup(m => m.AddProductAsync(Moq.It.IsAny <Product>(), null, null, CancellationToken.None)).Returns(fakeCall); Assert.Same(fakeCall, mockClient.Object.AddProductAsync(new Product())); }
public override AsyncUnaryCall <ListDevicesResponse> ListDevicesAsync(ListDevicesRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { var response = new ListDevicesResponse(); response.Devices.Add(Devices.Values); return(TestCalls.AsyncUnaryCall( Task.FromResult(response), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public override AsyncUnaryCall <ListMetricsResponse> ListMetricsAsync(ListMetricsRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { DateTimeOffset endDateTime; if (string.IsNullOrEmpty(request.PageToken)) { endDateTime = request.EndTime?.ToDateTimeOffset() ?? DateTimeOffset.UtcNow; } else { endDateTime = DateTimeOffset.Parse(request.PageToken, CultureInfo.InvariantCulture); } endDateTime = endDateTime.ToUniversalTime(); var startDateTime = request.StartTime?.ToDateTime(); var metrics = new List <Metric>(request.PageSize); for (int i = 0; i < request.PageSize; i++) { endDateTime = endDateTime.Subtract(TimeSpan.FromSeconds(5)); if (startDateTime.HasValue && startDateTime > endDateTime) { break; } metrics.Add(new Metric { CreateTime = Timestamp.FromDateTimeOffset(endDateTime), InputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), OutputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), HeaterOutputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), EnvironmentCelsiusDegree = RandomUtils.NextFloat(10, 20), HeaterPowerKilowatt = RandomUtils.NextFloat(0, 12), WaterPumpFlowRateCubicMeterPerHour = RandomUtils.NextFloat(1, 3), }); } var response = new ListMetricsResponse { NextPageToken = endDateTime.ToUniversalTime().ToString(CultureInfo.InvariantCulture), }; response.Metrics.AddRange(metrics); return(TestCalls.AsyncUnaryCall( Task.FromResult(response), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
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); }
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); }
public override AsyncUnaryCall <ListAlarmChangesResponse> ListAlarmChangesAsync(ListAlarmChangesRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { DateTimeOffset endDateTime; if (string.IsNullOrEmpty(request.PageToken)) { endDateTime = request.EndTime?.ToDateTimeOffset() ?? DateTimeOffset.UtcNow; } else { endDateTime = DateTimeOffset.Parse(request.PageToken, CultureInfo.InvariantCulture); } endDateTime = endDateTime.ToUniversalTime(); var startDateTime = request.StartTime?.ToDateTime(); var alarmChanges = new List <AlarmChange>(request.PageSize); for (int i = 0; i < request.PageSize; i++) { endDateTime = endDateTime.Subtract(TimeSpan.FromSeconds(5)); if (startDateTime.HasValue && startDateTime > endDateTime) { break; } alarmChanges.Add(new AlarmChange { CreateTime = Timestamp.FromDateTimeOffset(endDateTime), AlarmType = (AlarmType)RandomUtils.Next(1, 7), AlarmChangeDirection = (AlarmChangeDirection)RandomUtils.Next(1, 3), }); } var response = new ListAlarmChangesResponse { NextPageToken = endDateTime.ToUniversalTime().ToString(CultureInfo.InvariantCulture), }; response.AlarmChanges.AddRange(alarmChanges); return(TestCalls.AsyncUnaryCall( Task.FromResult(response), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public override AsyncUnaryCall <Metric> GetMetricAsync(GetMetricRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { return(TestCalls.AsyncUnaryCall( Task.FromResult(new Metric { InputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), OutputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), HeaterOutputWaterCelsiusDegree = RandomUtils.NextFloat(10, 20), EnvironmentCelsiusDegree = RandomUtils.NextFloat(10, 20), HeaterPowerKilowatt = RandomUtils.NextFloat(0, 12), WaterPumpFlowRateCubicMeterPerHour = RandomUtils.NextFloat(1, 3), }), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
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); }
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); }
public override AsyncUnaryCall <AuthenticateResponse> AuthenticateAsync( AuthenticateRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { if (request.Username == "user" && request.Password == "user") { return(TestCalls.AsyncUnaryCall( Task.FromResult( new AuthenticateResponse() { Nickname = "用户1", Role = UserRole.User, }), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); } else if (request.Username == "admin" && request.Password == "admin") { return(TestCalls.AsyncUnaryCall( Task.FromResult( new AuthenticateResponse() { Nickname = "管理员1", Role = UserRole.Administrator, }), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); } else { var status = new Status(StatusCode.Unauthenticated, "Invalid username or password."); return(TestCalls.AsyncUnaryCall( Task.FromException <AuthenticateResponse>(new RpcException(status)), Task.FromResult(new Metadata()), () => status, () => new Metadata(), () => { })); } }
public override AsyncUnaryCall <WorkingMode> UpdateWorkingModeAsync(UpdateWorkingModeRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { WorkingMode workingMode = WorkingModes[request.DeviceId]; if (request.UpdateMask == null) { workingMode.MergeFrom(request.WorkingMode); } else { request.UpdateMask.Merge(request.WorkingMode, workingMode); } return(TestCalls.AsyncUnaryCall( Task.FromResult(workingMode), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public override AsyncUnaryCall <RunningParameter> UpdateRunningParameterAsync(UpdateRunningParameterRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { RunningParameter runningParameter = RunningParameters[request.DeviceId]; if (request.UpdateMask == null) { runningParameter.MergeFrom(request.RunningParameter); } else { request.UpdateMask.Merge(request.RunningParameter, runningParameter); } return(TestCalls.AsyncUnaryCall( Task.FromResult(runningParameter), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
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); }
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); }
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); }
public async Task Connect_InboundPeerIsEarlier_Test() { var mockClient = new Mock <PeerService.PeerServiceClient>(); var confirmHandshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(new VoidReply()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(confirmHandshakeCall); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); peer.UpdateLastReceivedHandshake(new Handshake { HandshakeData = new HandshakeData { LastIrreversibleBlockHeight = 1, BestChainHash = HashHelper.ComputeFrom("BestChainHash"), BestChainHeight = 10, Time = TimestampHelper.GetUtcNow().AddMinutes(-1) } }); _peerPool.TryAddPeer(peer); AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint); var added = await _connectionService.ConnectAsync(endpoint); added.ShouldBeTrue(); var currentPeer = _peerPool.FindPeerByEndpoint(endpoint); currentPeer.ShouldBeNull(); AElfPeerEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out endpoint); currentPeer = _peerPool.FindPeerByEndpoint(endpoint); currentPeer.ShouldNotBeNull(); }
public override AsyncUnaryCall <Switch> UpdateSwitchAsync(UpdateSwitchRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default) { Switch switchInfo = Switches[request.DeviceId] ?? new Switch(); if (request.UpdateMask == null) { switchInfo.MergeFrom(request.Switch); } else { request.UpdateMask.Merge(request.Switch, switchInfo); } Switches[request.DeviceId] = switchInfo; return(TestCalls.AsyncUnaryCall( Task.FromResult(switchInfo.Clone()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { })); }
public async Task Throws_If_Request_FailsAsync() { var mockOrg = new Organization("Mock", false); var mockRepo = new Mock <IOrganizationRepository>(); // Ensure repo returns a valid org mockRepo.Setup(m => m.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(Option <Organization> .Some(mockOrg)); // Construct fake reply var failedResult = new TenantDeletionOutcome() { Success = false }; var mockReply = TestCalls.AsyncUnaryCall <TenantDeletionOutcome>(Task.FromResult(failedResult), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); // Ensure client returns fake reply (https://github.com/grpc/grpc/tree/master/src/csharp/Grpc.Examples.Tests for examples) var mockClient = new Mock <DeleteTenant.DeleteTenantClient>(); mockClient.Setup(m => m.DeleteAsync(It.IsAny <TenantDeletionRequest>(), null, null, CancellationToken.None)).Returns(mockReply); var job = new TenantCleanupJob(mockRepo.Object, mockClient.Object); await Assert.ThrowsAsync <Exception>(() => job.RunAsync(mockOrg.Id, CancellationToken.None)); }
/// <inheritdoc /> public override AsyncUnaryCall <TResponse> Build() => TestCalls.AsyncUnaryCall(_response, ResponseHeaders, StatusFunc, TrailersFunc, DisposeAction);
public override void ConfigureServices(ServiceConfigurationContext context) { var netTestHelper = new NetworkTestContextHelpers(); context.Services.AddSingleton(netTestHelper); Configure <NetworkOptions>(o => { o.ListeningPort = 2001; o.MaxPeers = 2; }); context.Services.AddTransient(o => { var mockHandshakeProvider = new Mock <IHandshakeProvider>(); mockHandshakeProvider.Setup(h => h.GetHandshakeAsync()).ReturnsAsync(new Handshake()); return(mockHandshakeProvider.Object); }); context.Services.AddTransient(sp => { var mockDialer = new Mock <IPeerDialer>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint))) .Returns <IPEndPoint>(s => { var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint2))) .Returns <IPEndPoint>(s => { var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.DialExceptionIpEndpoint))) .Throws <PeerDialException>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp))) .Returns <IPEndPoint>(s => { var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)) .Throws(new AggregateException()); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey, mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); // Incorrect handshake mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.BadHandshakeIp))) .Returns <IPEndPoint>((s) => { var handshakeReply = new HandshakeReply { Error = HandshakeError.InvalidHandshake, }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); // This peer will pass all checks with success. mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.GoodPeerEndpoint))) .Returns <IPEndPoint>(s => { var keypair = CryptoHelper.GenerateKeyPair(); var handshakeReply = new HandshakeReply { Error = HandshakeError.HandshakeOk, Handshake = netTestHelper.CreateValidHandshake(keypair, 10) }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, keypair.PublicKey.ToHex(), mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); return(mockDialer.Object); }); }
public override void ConfigureServices(ServiceConfigurationContext context) { Configure <NetworkOptions>(o => { o.ListeningPort = 2001; o.MaxPeers = 2; }); context.Services.AddTransient(o => { var mockBlockchainService = new Mock <IBlockchainService>(); var keyPair = CryptoHelper.GenerateKeyPair(); mockBlockchainService.Setup(b => b.GetChainAsync()).ReturnsAsync(new Chain { Id = NetworkTestConstants.DefaultChainId }); mockBlockchainService.Setup(b => b.GetChainId()).Returns(NetworkTestConstants.DefaultChainId); mockBlockchainService.Setup(b => b.GetBlockHeaderByHashAsync(It.IsAny <Hash>())).ReturnsAsync( NetworkTestHelper.CreateFakeBlockHeader(NetworkTestConstants.DefaultChainId, 1, keyPair)); return(mockBlockchainService.Object); }); context.Services.AddTransient(sp => { var mockDialer = new Mock <IPeerDialer>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint))) .Returns <DnsEndPoint>(s => { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint2))) .Returns <DnsEndPoint>(s => { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants .DialExceptionIpEndpoint))) .Returns(Task.FromResult <GrpcPeer>(null)); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp))) .Returns <DnsEndPoint>(s => { var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)) .Throws(new AggregateException()); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey, mockClient.Object); return(Task.FromResult(peer)); }); // Incorrect handshake mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.BadHandshakeIp))) .Returns <DnsEndPoint>((s) => { var handshakeReply = new HandshakeReply(); var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Throws(new AggregateException()); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); return(Task.FromResult(peer)); }); // Incorrect handshake signature mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants .HandshakeWithDataExceptionIp))) .Returns <string>(async(s) => { var handshakeProvider = context.Services.GetServiceLazy <IHandshakeProvider>().Value; var handshake = await handshakeProvider.GetHandshakeAsync(); handshake.HandshakeData.Time = null; var handshakeReply = new HandshakeReply { Handshake = handshake }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); return(peer); }); // This peer will pass all checks with success. mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint))) .Returns <DnsEndPoint>(s => { var keyPair = CryptoHelper.GenerateKeyPair(); var handshakeReply = new HandshakeReply { Handshake = NetworkTestHelper.CreateValidHandshake(keyPair, 10) }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var confirmHandshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(new VoidReply()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(confirmHandshakeCall); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); peer.UpdateLastSentHandshake(handshakeReply.Handshake); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialBackPeerAsync(It.IsAny <DnsEndPoint>(), It.IsAny <Handshake>())) .Returns <DnsEndPoint, Handshake>((endPoint, handshake) => { if (endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint) { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); } return(Task.FromResult <GrpcPeer>(null)); }); return(mockDialer.Object); }); }