public async Task ForInitialRequest_UsingBalanceLoad_EnsureResponseMessages()
{
// Arrange
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var firstRequest = new LoadBalanceRequest()
{
ClientStats = GetInitialClientStats()
};
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(firstRequest);
var hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var firstResponse = balancingStreaming.ResponseStream.Current;
var secondRequest = new LoadBalanceRequest()
{
ClientStats = GetSuccessClientStats()
};
await balancingStreaming.RequestStream.WriteAsync(secondRequest);
hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var secondResponse = balancingStreaming.ResponseStream.Current;
await balancingStreaming.RequestStream.CompleteAsync();
// Assert
AssertServerListForClientStats(firstResponse);
AssertServerListForClientStats(secondResponse);
}
public async Task ForWrongServiceName_UsingBalanceLoadValidateServiceName_ThrowException()
{
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var initialRequest = new InitialLoadBalanceRequest()
{
Name = "wrong-service-name"
};
var request = new LoadBalanceRequest()
{
InitialRequest = initialRequest
};
// Act
// Assert
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(request);
await balancingStreaming.RequestStream.CompleteAsync();
var exception = await Assert.ThrowsAsync <RpcException>(async() =>
{
var _ = await balancingStreaming.ResponseStream.MoveNext();
});
Assert.Equal(StatusCode.Unknown, exception.StatusCode);
}
public async Task ForCorrectServiceName_UsingBalanceLoadValidateServiceName_ReturnResponse()
{
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var initialRequest = new InitialLoadBalanceRequest()
{
Name = "test-service-name"
};
var request = new LoadBalanceRequest()
{
InitialRequest = initialRequest
};
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(request);
await balancingStreaming.RequestStream.CompleteAsync();
var hasFirstElement = await balancingStreaming.ResponseStream.MoveNext();
var hasSecondElement = await balancingStreaming.ResponseStream.MoveNext();
// Assert
Assert.True(hasFirstElement);
Assert.True(hasSecondElement);
}
public async Task ForInitialRequest_UsingBalanceLoadCheckReportInterval_ReturnFiveSeconds()
{
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var initialRequest = new InitialLoadBalanceRequest()
{
Name = "test-service-name"
};
var request = new LoadBalanceRequest()
{
InitialRequest = initialRequest
};
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(request);
await balancingStreaming.RequestStream.CompleteAsync();
var hasFirstElement = await balancingStreaming.ResponseStream.MoveNext();
var response = balancingStreaming.ResponseStream.Current;
var hasSecondElement = await balancingStreaming.ResponseStream.MoveNext();
// Assert
Assert.True(hasFirstElement);
Assert.True(hasSecondElement);
Assert.Equal(LoadBalanceResponse.LoadBalanceResponseTypeOneofCase.InitialResponse, response.LoadBalanceResponseTypeCase);
Assert.NotNull(response.InitialResponse);
Assert.Equal(TimeSpan.FromSeconds(5), response.InitialResponse.ClientStatsReportInterval.ToTimeSpan());
}
public async Task ForInitialRequest_UsingBalanceLoad_EnsureResponseMessages()
{
// Arrange
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var firstRequest = new LoadBalanceRequest()
{
ClientStats = GetInitialClientStats()
};
// balancer start with normal mode
// Act
// Assert
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(firstRequest);
var hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var firstResponse = balancingStreaming.ResponseStream.Current;
Assert.Equal(LoadBalanceResponseTypeOneofCase.ServerList, firstResponse.LoadBalanceResponseTypeCase);
await SwitchBalancerFallbackMode(_client); // switch to fallback mode
var secondRequest = new LoadBalanceRequest()
{
ClientStats = GetSuccessClientStats()
};
await balancingStreaming.RequestStream.WriteAsync(secondRequest);
hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var secondResponse = balancingStreaming.ResponseStream.Current;
Assert.Equal(LoadBalanceResponseTypeOneofCase.FallbackResponse, secondResponse.LoadBalanceResponseTypeCase);
await SwitchBalancerFallbackMode(_client); // switch to normal mode
var thirdRequest = new LoadBalanceRequest()
{
ClientStats = GetSuccessClientStats()
};
await balancingStreaming.RequestStream.WriteAsync(thirdRequest);
hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var thirdResponse = balancingStreaming.ResponseStream.Current;
Assert.Equal(LoadBalanceResponseTypeOneofCase.ServerList, thirdResponse.LoadBalanceResponseTypeCase);
await balancingStreaming.RequestStream.CompleteAsync();
}
public async Task ForNoneRequest_UsingBalanceLoad_EnsureNoResponse()
{
// Arrange
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var request = new LoadBalanceRequest();
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(request);
await balancingStreaming.RequestStream.CompleteAsync();
var hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
// Assert
Assert.Equal(LoadBalanceRequest.LoadBalanceRequestTypeOneofCase.None, request.LoadBalanceRequestTypeCase);
Assert.False(hasNextElement);
}
public async Task ForNoRequests_UsingBalanceLoad_EnsureGracefulClose()
{
// Arrange
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.CompleteAsync();
var hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
balancingStreaming.Dispose();
// Assert
Assert.False(hasNextElement);
Assert.Equal(StatusCode.OK, balancingStreaming.GetStatus().StatusCode);
Assert.Equal(TaskStatus.RanToCompletion, balancingStreaming.ResponseHeadersAsync.Status);
}
public async Task ForInitialRequest_UsingBalanceLoad_EnsureResponseMessages()
{
// Arrange
var balancerClient = new LoadBalancer.LoadBalancerClient(_channel);
var initialRequest = new InitialLoadBalanceRequest()
{
Name = "test-service-name"
};
var request = new LoadBalanceRequest()
{
InitialRequest = initialRequest
};
// Act
using var balancingStreaming = balancerClient.BalanceLoad();
await balancingStreaming.RequestStream.WriteAsync(request);
await balancingStreaming.RequestStream.CompleteAsync();
var hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var initialResponse = balancingStreaming.ResponseStream.Current;
hasNextElement = await balancingStreaming.ResponseStream.MoveNext();
Assert.True(hasNextElement);
var secondResponse = balancingStreaming.ResponseStream.Current;
// Assert
Assert.Equal(LoadBalanceResponseTypeOneofCase.InitialResponse, initialResponse.LoadBalanceResponseTypeCase);
Assert.NotNull(initialResponse.InitialResponse);
Assert.Equal(TimeSpan.FromSeconds(10), initialResponse.InitialResponse.ClientStatsReportInterval.ToTimeSpan());
Assert.Equal(LoadBalanceResponseTypeOneofCase.ServerList, secondResponse.LoadBalanceResponseTypeCase);
Assert.NotNull(secondResponse.ServerList);
Assert.Equal(3, secondResponse.ServerList.Servers.Count);
Assert.All(secondResponse.ServerList.Servers, server =>
{
Assert.StartsWith("10.1.6.", new IPAddress(server.IpAddress.ToByteArray()).ToString());
Assert.Equal(80, server.Port);
Assert.False(string.IsNullOrWhiteSpace(server.LoadBalanceToken));
});
}
