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);
});
}