public async Task SendAsync_ShouldRepeatRequest_WithRefreshedAccessToken()
{
// Arrange
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(
new RefreshTokenResponse {
AccessToken = "New access token", RefreshToken = "New refresh token"
}));
var handler = new UnauthorizedResponseHandler(_tokenClient, _tokenStorage, _userStorage)
{
InnerHandler = _innerHandler
};
var client = new HttpClient(handler)
{
BaseAddress = _baseAddress
};
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/logicals")
.Respond(HttpStatusCode.Unauthorized);
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/logicals")
.WithHeaders("Authorization", "Bearer New access token")
.Respond(HttpStatusCode.OK);
// Act
var request = new HttpRequestMessage(HttpMethod.Get, "/logicals");
await client.SendAsync(request);
// Assert
_innerHandler.VerifyNoOutstandingExpectation();
}
public async Task SendAsync_ShouldSet_TokenStorage_Tokens()
{
// Arrange
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(
new RefreshTokenResponse {
AccessToken = "New access token", RefreshToken = "New refresh token"
}));
var handler = new UnauthorizedResponseHandler(_tokenClient, _tokenStorage, _userStorage)
{
InnerHandler = _innerHandler
};
var client = new HttpClient(handler)
{
BaseAddress = _baseAddress
};
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/logicals")
.Respond(HttpStatusCode.Unauthorized);
// Act
var request = new HttpRequestMessage(HttpMethod.Get, "/logicals");
await client.SendAsync(request);
// Assert
_tokenStorage.AccessToken.Should().Be("New access token");
_tokenStorage.RefreshToken.Should().Be("New refresh token");
}
public async Task TrafficShouldBeForwardedWhenUserLocationServiceReturns(string ip, string currentConnectedIP, bool expected)
{
// Arrange
var response = ApiResponseResult <UserLocation> .Ok(new UserLocation
{
Ip = ip
});
_vpnConfig.BlackHoleIps.Returns(new List <string> {
"62.112.9.168", "104.245.144.186"
});
_userLocationService.LocationAsync().Returns(response);
var subject = new ForwardedTraffic(_userLocationService, _vpnConfig);
await subject.OnVpnStateChanged(new VpnStateChangedEventArgs(
VpnStatus.Connected,
VpnError.None,
GetConnectedServer(currentConnectedIP),
false,
VpnProtocol.Auto));
// Act
var result = await subject.Value();
// Assert
result.Forwarded.Should().Be(expected);
}
private async Task <ApiResponseResult <CertificateResponseData> > MockOfRequestAuthCertificateAsync(CertificateRequestData arg)
{
if (arg.ClientPublicKey.IsNullOrEmpty() || _usedClientPublicKeys.Contains(arg.ClientPublicKey))
{
return(ApiResponseResult <CertificateResponseData> .Fail(CreateClientPublicKeyConflictCertificateResponseData(),
HttpStatusCode.BadRequest, string.Empty));
}
_usedClientPublicKeys.Add(arg.ClientPublicKey);
_certificateResponseData ??= CreateCertificateResponseData();
return(ApiResponseResult <CertificateResponseData> .Ok(_certificateResponseData));
}
public void TestInitialize()
{
_tokenClient = Substitute.For <ITokenClient>();
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(new RefreshTokenResponse()));
_tokenStorage = Substitute.For <ITokenStorage>();
_tokenStorage.AccessToken.Returns("Access token");
_tokenStorage.RefreshToken.Returns("Refresh token");
_tokenStorage.Uid.Returns(string.Empty);
_innerHandler = new MockHttpMessageHandler();
}
public void TestInitialize()
{
_apiClient = Substitute.For <IApiClient>();
_userStorage = Substitute.For <IUserStorage>();
var result = ApiResponseResult <VpnInfoResponse> .Ok(new VpnInfoResponse
{
Code = 1000,
Error = string.Empty
});
_apiClient.GetVpnInfoResponse().Returns(Task.FromResult(result));
}
private void SetSessions(int number)
{
var sessions = new List <Session>();
for (var i = 0; i < number; i++)
{
sessions.Add(new Session());
}
_apiClient.GetSessions().Returns(Task.FromResult(ApiResponseResult <SessionsResponse> .Ok(new SessionsResponse
{
Code = 1000,
Error = string.Empty,
Sessions = sessions
})));
}
public async Task <ApiResponseResult <BaseResponse> > GetValidateResult()
{
if (PlanInfoExists())
{
return(ApiResponseResult <BaseResponse> .Ok(new BaseResponse()));
}
var vpnInfoResult = await _userAuth.RefreshVpnInfo();
if (vpnInfoResult.Success)
{
_userStorage.StoreVpnInfo(vpnInfoResult.Value);
return(ApiResponseResult <BaseResponse> .Ok(vpnInfoResult.Value));
}
return(ApiResponseResult <BaseResponse> .Fail(vpnInfoResult.StatusCode, vpnInfoResult.Error));
}
public void TestInitialize()
{
_apiClient = Substitute.For <IApiClient>();
_userStorage = Substitute.For <IUserStorage>();
_serverUpdater = Substitute.For <IServerUpdater>();
_appSettings = Substitute.For <IAppSettings>();
_logger = Substitute.For <ILogger>();
_serverManager = Substitute.For <ServerManager>(_userStorage, _appSettings, _logger);
ApiResponseResult <VpnInfoResponse> result = ApiResponseResult <VpnInfoResponse> .Ok(new VpnInfoResponse
{
Code = 1000,
Error = string.Empty
});
_apiClient.GetVpnInfoResponse().Returns(Task.FromResult(result));
}
public async Task Detected_ShouldBe_WhenUserLocationService_Returns(string ip, bool expected)
{
// Arrange
var response = ApiResponseResult <UserLocation> .Ok(new UserLocation
{
Ip = ip
});
_vpnConfig.BlackHoleIps.Returns(new List <string> {
"62.112.9.168", "104.245.144.186"
});
_userLocationService.LocationAsync().Returns(response);
var subject = new ForwardedTraffic(_userLocationService, _vpnConfig);
// Act
var result = await subject.Value();
// Assert
result.Forwarded.Should().Be(expected);
}
public void TestInitialize()
{
_tokenClient = Substitute.For <ITokenClient>();
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(new RefreshTokenResponse()));
_tokenStorage = Substitute.For <ITokenStorage>();
_tokenStorage.AccessToken.Returns("Access token");
_tokenStorage.RefreshToken.Returns("Refresh token");
_tokenStorage.Uid.Returns("User ID");
_userStorage = Substitute.For <IUserStorage>();
_userStorage.User().Returns(new Core.Models.User {
Username = "******"
});
_logger = Substitute.For <ILogger>();
_innerHandler = new MockHttpMessageHandler();
}
public async Task SendAsync_ShouldRetryWithNewToken_WhenRefreshedWhileRequesting()
{
// Arrange
var breakpointHandler = new BreakpointHandler {
InnerHandler = _innerHandler
};
var requestBreakpoint = breakpointHandler.Breakpoint;
var breakpointTokenClient = new BreakpointTokenClient(_tokenClient);
var tokenClientBreakpoint = breakpointTokenClient.Breakpoint;
var handler = new UnauthorizedResponseHandler(breakpointTokenClient, _tokenStorage, _userStorage)
{
InnerHandler = breakpointHandler
};
var client = new HttpClient(handler)
{
BaseAddress = _baseAddress
};
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(
new RefreshTokenResponse {
AccessToken = "New access token", RefreshToken = "New refresh token"
}));
var response = new HttpResponseMessage(HttpStatusCode.OK);
// Act
var task1 = Task.CompletedTask;
var task2 = Task.CompletedTask;
try
{
// Sending first request and pausing it
var request1 = new HttpRequestMessage(HttpMethod.Get, "/vpn");
task1 = client.SendAsync(request1);
var request1Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
// Sending second request and pausing it
var request2 = new HttpRequestMessage(HttpMethod.Get, "/profiles");
task2 = client.SendAsync(request2);
var request2Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
// Continue first request and get Unauthorized
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/vpn")
.Respond(HttpStatusCode.Unauthorized);
request1Hit.Continue();
// First request initiated token refresh
await tokenClientBreakpoint.WaitForHitAndContinue().TimeoutAfter(TestTimeout);
// First request retried with new tokens
request1Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/vpn")
.WithHeaders("Authorization", "Bearer New access token")
.Respond(req => response);
request1Hit.Continue();
await task1.TimeoutAfter(TestTimeout);
// Second request continues and gets Unauthorized
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/profiles")
.Respond(HttpStatusCode.Unauthorized);
request2Hit.Continue();
// Second request retried with new access token
request2Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/profiles")
.WithHeaders("Authorization", "Bearer New access token")
.Respond(req => response);
request2Hit.Continue();
}
finally
{
await task1.TimeoutAfter(TestTimeout);
await task2.TimeoutAfter(TestTimeout);
}
// Assert
await _tokenClient.Received(1).RefreshTokenAsync(Arg.Any <CancellationToken>());
_innerHandler.VerifyNoOutstandingExpectation();
}
