public async Task ReportMetricAsync_MetricIdAndValueAreProvided_Succeeds()
{
// Arrange
var pageId = _bogus.Name.FirstName();
var metricId = _bogus.Name.FirstName();
var metricValue = _bogus.Random.Double();
var fakeHttpMessageHandler = new HttpMessageHandlerStub();
var sinkConfiguration = BogusAtlassianStatuspageMetricSinkConfigurationGenerator.GetSinkConfiguration(pageId: pageId);
var atlassianStatuspageClient = new AtlassianStatuspageClient(httpClient: new HttpClient(fakeHttpMessageHandler), sinkConfiguration, NullLogger <AtlassianStatuspageClient> .Instance);
// Act
await atlassianStatuspageClient.ReportMetricAsync(metricId, metricValue);
// Assert
var request = fakeHttpMessageHandler.LastRequest;
Assert.NotNull(request);
Assert.Equal(HttpMethod.Post, request.Method);
Assert.Equal($"https://api.statuspage.io/v1/pages/{pageId}/metrics/{metricId}/data", request.RequestUri.ToString());
var requestBody = await request.Content.ReadAsStringAsync();
var requestToken = JToken.Parse(requestBody);
Assert.Equal(metricValue.ToString(CultureInfo.InvariantCulture), requestToken["data"]?["value"]?.ToString());
}
public async Task DeleteAsync_given_Conflict_returns_false()
{
var resource = "https://foo.bar";
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.Conflict
};
var httpClient = new HttpClient(handler);
var client = new RestClient(httpClient);
var response = await client.DeleteAsync(resource);
Assert.False(response);
}
public async Task CreateDocumentAsync_ReturnsPrimedDocumentWhenDiscoveryEndpointReturnsValidResponse()
{
var cancellationToken = new CancellationToken();
var logger = new Moq.Mock <ILogger <WopiDiscoveryDocumentFactory> >().Object;
var services = new ServiceCollection();
services.AddMemoryCache();
var serviceProvider = services.BuildServiceProvider();
var memoryCache = serviceProvider.GetRequiredService <IMemoryCache>();
var sourceEndpoint = new Uri(WopiDiscoveryDocumentTests.WOPI_ROOT + WopiDiscoveryDocumentTests.WOPI_DISCOVERY_DOCUMENT_URL, UriKind.Absolute);
var wopiConfiguration = new WopiConfiguration()
{
ClientDiscoveryDocumentUrl = sourceEndpoint.AbsoluteUri
};
var wopiConfigurationOptionsSnapshot = new Moq.Mock <IOptionsSnapshot <WopiConfiguration> >();
wopiConfigurationOptionsSnapshot.SetupGet(x => x.Value).Returns(wopiConfiguration);
var httpClientFactory = new Moq.Mock <IHttpClientFactory>();
var httpResponseMessage = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(WopiDiscoveryDocumentTests.WOPI_DISCOVERY_DOCUMENT_XML, Encoding.UTF8, "application/xml")
};
var httpMessageHandler = new HttpMessageHandlerStub((request, _) => httpResponseMessage);
var httpClient = new HttpClient(httpMessageHandler, true);
httpClientFactory.Setup(x => x.CreateClient("wopi-discovery-document")).Returns(httpClient);
var newWopiDiscoveryDocument = new Moq.Mock <IWopiDiscoveryDocument>().Object;
var wopiDiscoveryDocumentRepository = new Moq.Mock <IWopiDiscoveryDocumentRepository>();
wopiDiscoveryDocumentRepository.Setup(x => x.GetAsync(Moq.It.IsAny <CancellationToken>())).Returns(Task.FromResult(newWopiDiscoveryDocument));
IWopiDiscoveryDocumentFactory wopiDiscoveryDocumentFactory = new WopiDiscoveryDocumentFactory(memoryCache, wopiDiscoveryDocumentRepository.Object, logger);
var wopiDiscoveryDocument = await wopiDiscoveryDocumentFactory.CreateDocumentAsync(cancellationToken);
Assert.IsFalse(wopiDiscoveryDocument.IsEmpty, "Expected a none empty document to be returned when the discovery endpoint is known and returns a valid response");
}
public async Task PostAsync_given_resource_returns_location()
{
var resource = "https://foo.bar";
var type = new TestType();
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.Created, Location = new Uri("https://foo.bar/data/2")
};
var httpClient = new HttpClient(handler);
var client = new RestClient(httpClient);
var response = await client.PostAsync(resource, type);
Assert.Equal(new Uri("https://foo.bar/data/2"), response);
}
public async Task PutAsync_given_NoContent_returns_true()
{
var resource = "https://foo.bar";
var type = new TestType();
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.NoContent
};
var httpClient = new HttpClient(handler);
var client = new RestClient(httpClient);
var response = await client.PutAsync(resource, type);
Assert.True(response);
}
public void Init()
{
TokenProvider = new CamundaCloudTokenProviderBuilder()
.UseAuthServer("https://local.de")
.UseClientId("ID")
.UseClientSecret("SECRET")
.UseAudience("AUDIENCE")
.Build();
MessageHandlerStub = new HttpMessageHandlerStub();
TokenProvider.HttpMessageHandler = MessageHandlerStub;
TokenStoragePath = Path.GetTempPath() + ".zeebe/";
TokenProvider.TokenStoragePath = TokenStoragePath;
ExpiresIn = 3600;
Token = "REQUESTED_TOKEN";
}
public async Task GetAsync_given_resource_returns_converted()
{
var resource = "https://foo.bar";
var json = "{\"id\":1,\"name\":\"foo\"}";
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.OK, Content = json
};
var httpClient = new HttpClient(handler);
var client = new RestClient(httpClient);
var response = await client.GetAsync <TestType>(resource);
Assert.Equal(1, response.Id);
Assert.Equal("foo", response.Name);
}
public async Task DeleteAsync_given_Conflict_returns_Conflict()
{
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.Conflict
};
var httpClient = new HttpClient(handler);
var settings = new Mock <ISettings>();
settings.SetupGet(s => s.BackendUrl).Returns(new Uri("https://foo.bar"));
var service = new Mock <IAuthenticationService>();
var client = new RestClient(httpClient, settings.Object, service.Object);
var response = await client.DeleteAsync("items");
Assert.Equal(HttpStatusCode.Conflict, response);
}
public async Task GetAllAsync_given_resource_returns_converted()
{
var resource = "https://foo.bar";
var json = "[{\"id\":1,\"name\":\"foo\"},{\"id\":2,\"name\":\"bar\"}]";
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.OK, Content = json
};
var httpClient = new HttpClient(handler);
var client = new RestClient(httpClient);
var response = await client.GetAllAsync <TestType>(resource);
Assert.Collection(response,
d => { Assert.Equal(1, d.Id); Assert.Equal("foo", d.Name); },
d => { Assert.Equal(2, d.Id); Assert.Equal("bar", d.Name); });
}
public async Task Should_build_the_certificate_chain_when_intermediate()
{
var caInt = await File.ReadAllTextAsync("Content\\ca_int.pem");
var caRoot = await File.ReadAllTextAsync("Content\\ca_root.pem");
var expected = await File.ReadAllTextAsync("Content\\chain_int_root.pem");
var handler = new HttpMessageHandlerStub();
handler.AddRequestResponse("http://trust.quovadisglobal.com/qvrca2g3.crt", caRoot);
var client = new HttpClient(handler);
var x509 = new X509ChainComposer(client);
var result = await x509.ComposeChain(caInt);
AssertExt.Equal(expected, result.ToPem());
}
public async void Authenticate_Fails()
{
var mockInvoker = new HttpMessageHandlerStub((HttpRequestMessage req, CancellationToken token) =>
{
var res = new HttpResponseMessage();
res.RequestMessage = req;
res.Version = new Version(1, 1);
res.StatusCode = HttpStatusCode.InternalServerError;
res.ReasonPhrase = HttpStatusCode.InternalServerError.ToString();
return(Task.FromResult(res));
});
// we'll use these to ensure our handlers are given time to run
TaskCompletionSource <int> codeCompleteSrc = new TaskCompletionSource <int>();
HttpClient httpClient = new HttpClient(mockInvoker);
OAuth24DClient client = new OAuth24DClient("http://example.com/code", "http://example.com/poll", httpClient);
client.CodeComplete += (OAuth24DClient.CodeCompletionData codeData) =>
{
try
{
Assert.Null(codeData.device_code);
Assert.Null(codeData.user_code);
Assert.Equal(0, codeData.interval);
Assert.Null(codeData.verification_url);
Assert.Equal(500, codeData.http_status);
}
catch (Exception ex)
{
codeCompleteSrc.SetException(ex);
}
codeCompleteSrc.SetResult(0);
};
Assert.True(client.Authenticate());
// wait until the handlers are fired and validated
await codeCompleteSrc.Task;
}
public async Task PostAsync_given_resource_returns_location()
{
var type = new TestType();
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.Created, Location = new Uri("https://foo.bar/data/2")
};
var httpClient = new HttpClient(handler);
var settings = new Mock <ISettings>();
settings.SetupGet(s => s.BackendUrl).Returns(new Uri("https://foo.bar"));
var service = new Mock <IAuthenticationService>();
var client = new RestClient(httpClient, settings.Object, service.Object);
var(_, response) = await client.PostAsync("items", type);
Assert.Equal(new Uri("https://foo.bar/data/2"), response);
}
public void Init()
{
_requestUri = "https://local.de";
_clientId = "ID";
_clientSecret = "SECRET";
_audience = "AUDIENCE";
TokenProvider = new CamundaCloudTokenProviderBuilder()
.UseAuthServer(_requestUri)
.UseClientId(_clientId)
.UseClientSecret(_clientSecret)
.UseAudience(_audience)
.Build();
MessageHandlerStub = new HttpMessageHandlerStub();
TokenProvider.SetHttpMessageHandler(MessageHandlerStub);
TokenStoragePath = Path.GetTempPath() + ".zeebe/";
TokenProvider.TokenStoragePath = TokenStoragePath;
ExpiresIn = 3600;
Token = "REQUESTED_TOKEN";
}
public async Task GetAsync_given_resource_returns_converted()
{
var json = "{\"id\":1,\"name\":\"foo\"}";
var handler = new HttpMessageHandlerStub {
StatusCode = HttpStatusCode.OK, Content = json
};
var httpClient = new HttpClient(handler);
var settings = new Mock <ISettings>();
settings.SetupGet(s => s.BackendUrl).Returns(new Uri("https://foo.bar"));
var service = new Mock <IAuthenticationService>();
var client = new RestClient(httpClient, settings.Object, service.Object);
var(_, response) = await client.GetAsync <TestType>("items");
Assert.Equal(1, response.Id);
Assert.Equal("foo", response.Name);
}
public RESTRequestTest(ITestOutputHelper output)
{
_output = output;
_testInputClass = new InputClass()
{
Message = "test input"
};
_testOutputClass = new OutputClass()
{
Message = "test output"
};
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(_testOutputClass))
};
var httpMessageHanderStub = new HttpMessageHandlerStub((request, cancellationToken) => Task.FromResult(httpResponseMessage));
_httpClient = new HttpClient(httpMessageHanderStub);
_restRequest = new RESTRequest <OutputClass, InputClass>(_httpClient);
}
public PlaceAutocompleteSearchProcessTest(ITestOutputHelper output)
{
_output = output;
_logger = new NullLogger();
_testOutputClass = new OutputClass {
Message = new List <string> {
"test output"
}
};
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(_testOutputClass))
};
var httpMessageHanderStub = new HttpMessageHandlerStub((request, cancellationToken) => Task.FromResult(httpResponseMessage));
_httpClient = new HttpClient(httpMessageHanderStub);
_restService = new RESTRequest <PlacesResponse, Dictionary <string, string> >(_httpClient);
var jsonFileHandler = new JsonFileHandler();
Globals.Credentials = jsonFileHandler.ReadJson <Credentials>(_credentialFile);
}
public void SetUp()
{
httpMessageHandlerStub = new HttpMessageHandlerStub();
httpClientWrapper = new HttpClientWrapper(new HttpClient(httpMessageHandlerStub));
}
public async void Authenticate_Succeeds()
{
var mockInvoker = new HttpMessageHandlerStub((HttpRequestMessage req, CancellationToken token) =>
{
var res = new HttpResponseMessage();
res.RequestMessage = req;
res.Version = new Version(1, 1);
if (req.RequestUri.AbsolutePath == "/code")
{
res.Content = new StringContent("{\"device_code\": \"1a1da233-099c-4434-9a3c-9d4bbecff192\",\"user_code\": \"6b7-4450\",\"expires_in\": 1800,\"interval\": 5,\"verification_url\": \"https://example.com/oauth24d/login\"}");
res.StatusCode = HttpStatusCode.OK;
res.ReasonPhrase = HttpStatusCode.OK.ToString();
}
else if (req.RequestUri.AbsolutePath == "/poll")
{
res.Content = new StringContent("{\"access_token\": \"aigojeroigjegrg3h48943759347t298g34guj39vj48932893==\"}");
res.StatusCode = HttpStatusCode.OK;
res.ReasonPhrase = HttpStatusCode.OK.ToString();
}
else
{
res.StatusCode = HttpStatusCode.InternalServerError;
res.ReasonPhrase = HttpStatusCode.InternalServerError.ToString();
}
return(Task.FromResult(res));
});
// we'll use these to ensure our handlers are given time to run
TaskCompletionSource <int> codeCompleteSrc = new TaskCompletionSource <int>();
TaskCompletionSource <int> authCompleteSrc = new TaskCompletionSource <int>();
HttpClient httpClient = new HttpClient(mockInvoker);
OAuth24DClient client = new OAuth24DClient("http://example.com/code", "http://example.com/poll", httpClient);
client.CodeComplete += (OAuth24DClient.CodeCompletionData codeData) =>
{
try
{
Assert.Equal("1a1da233-099c-4434-9a3c-9d4bbecff192", codeData.device_code);
Assert.Equal("6b7-4450", codeData.user_code);
Assert.Equal(5, codeData.interval);
Assert.Equal("https://example.com/oauth24d/login", codeData.verification_url);
Assert.Equal(200, codeData.http_status);
}
catch (Exception ex)
{
codeCompleteSrc.SetException(ex);
}
codeCompleteSrc.SetResult(0);
};
client.AuthenticationComplete += (OAuth24DClient.AuthCompletionData authData) =>
{
try
{
Assert.Equal("aigojeroigjegrg3h48943759347t298g34guj39vj48932893==", authData.access_token);
Assert.Equal(200, authData.http_status);
}
catch (Exception ex)
{
authCompleteSrc.SetException(ex);
}
authCompleteSrc.SetResult(0);
};
Assert.True(client.Authenticate());
// wait until the handlers are fired and validated
await Task.WhenAll(codeCompleteSrc.Task, authCompleteSrc.Task);
}
public HttpClientStub(HttpMessageHandlerStub httpMessageHandler)
: base(httpMessageHandler)
{
BaseAddress = new Uri("http://dummyUri");
_handlerStub = httpMessageHandler;
}
