public void Validate_WhenInteractionDefinesAProviderStateAndNoProviderStatesAreSupplied_ThrowsInvalidOperationException()
{
var pact = new ProviderServicePactFile
{
Consumer = new Party {
Name = "My client"
},
Provider = new Party {
Name = "My Provider"
},
Interactions = new List <ProviderServiceInteraction>
{
new ProviderServiceInteraction
{
ProviderState = "My Provider State",
Description = "My interaction"
}
}
};
var mockProviderServiceResponseComparer = Substitute.For <IProviderServiceResponseComparer>();
var fakeHttpClient = new FakeHttpClient();
var mockHttpRequestMessageMapper = Substitute.For <IHttpRequestMessageMapper>();
var mockProviderServiceResponseMapper = Substitute.For <IProviderServiceResponseMapper>();
var providerServiceValidator = new ProviderServiceValidator(
mockProviderServiceResponseComparer,
fakeHttpClient,
mockHttpRequestMessageMapper,
mockProviderServiceResponseMapper,
new Reporter(new NoOpReportOutputter()));
Assert.Throws <InvalidOperationException>(() => providerServiceValidator.Validate(pact, null));
}
public void Validate_WithInteractionsInPactFile_CallsValidateOnTheProviderServiceResponseValidator()
{
var pact = new ProviderServicePactFile
{
Consumer = new Party {
Name = "My client"
},
Provider = new Party {
Name = "My Provider"
},
Interactions = new List <ProviderServiceInteraction>
{
new ProviderServiceInteraction
{
Description = "My interaction"
}
}
};
var mockProviderServiceResponseComparer = Substitute.For <IProviderServiceResponseComparer>();
var fakeHttpClient = new FakeHttpClient();
var mockHttpRequestMessageMapper = Substitute.For <IHttpRequestMessageMapper>();
var mockProviderServiceResponseMapper = Substitute.For <IProviderServiceResponseMapper>();
var providerServiceValidator = new ProviderServiceValidator(
mockProviderServiceResponseComparer,
fakeHttpClient,
mockHttpRequestMessageMapper,
mockProviderServiceResponseMapper,
new Reporter(new NoOpReportOutputter()));
providerServiceValidator.Validate(pact, null);
mockProviderServiceResponseComparer.Received(1).Compare(Arg.Any <ProviderServiceResponse>(), Arg.Any <ProviderServiceResponse>());
}
public void Validate_WithNoInteractionsAndProviderStatesSetUpDefined_SetUpActionIsNotInvoked()
{
var actionInkoved = false;
var pact = new ProviderServicePactFile
{
Consumer = new Party {
Name = "My client"
},
Provider = new Party {
Name = "My Provider"
},
Interactions = null
};
var providerStates = new ProviderStates(setUp: () => { actionInkoved = true; }, tearDown: null);
var mockProviderServiceResponseComparer = Substitute.For <IProviderServiceResponseComparer>();
var fakeHttpClient = new FakeHttpClient();
var mockHttpRequestMessageMapper = Substitute.For <IHttpRequestMessageMapper>();
var mockProviderServiceResponseMapper = Substitute.For <IProviderServiceResponseMapper>();
var providerServiceValidator = new ProviderServiceValidator(
mockProviderServiceResponseComparer,
fakeHttpClient,
mockHttpRequestMessageMapper,
mockProviderServiceResponseMapper,
new Reporter(new NoOpReportOutputter()));
providerServiceValidator.Validate(pact, providerStates);
Assert.False(actionInkoved, "Provider states pact setUp action is not invoked");
}
public void Validate_WithEmptyInteractionsInPactFile_DoesNotCallHttpClientOrAnyOfTheMappersOrValidators()
{
var pact = new ProviderServicePactFile
{
Consumer = new Party {
Name = "My client"
},
Provider = new Party {
Name = "My Provider"
},
Interactions = new List <ProviderServiceInteraction>()
};
var mockProviderServiceResponseComparer = Substitute.For <IProviderServiceResponseComparer>();
var fakeHttpClient = new FakeHttpClient();
var mockHttpRequestMessageMapper = Substitute.For <IHttpRequestMessageMapper>();
var mockProviderServiceResponseMapper = Substitute.For <IProviderServiceResponseMapper>();
var providerServiceValidator = new ProviderServiceValidator(
mockProviderServiceResponseComparer,
fakeHttpClient,
mockHttpRequestMessageMapper,
mockProviderServiceResponseMapper,
new Reporter(new NoOpReportOutputter()));
providerServiceValidator.Validate(pact, null);
Assert.Equal(0, fakeHttpClient.SendAsyncCallCount);
mockProviderServiceResponseComparer.Received(0).Compare(Arg.Any <ProviderServiceResponse>(), Arg.Any <ProviderServiceResponse>());
mockHttpRequestMessageMapper.Received(0).Convert(Arg.Any <ProviderServiceRequest>());
mockProviderServiceResponseMapper.Received(0).Convert(Arg.Any <HttpResponseMessage>());
}
public async Task CompareLocalPackageToFeedPackageShouldCorrectlyInterpretFeedResponse(
string feedResponseContentName,
HttpStatusCode feedResponseStatusCode,
PackageFeedStatus expectedResult)
{
var localPackagePath = TestInputs.GetFullPath(Path.Combine("Nupkgs", "test-package-a.zip"));
var packageContentUrl = $"https://fakefeed.azure.com/nuget/v3/{feedResponseContentName}.nupkg";
var taskLoggingHelper = new Microsoft.Build.Utilities.TaskLoggingHelper(new StubTask());
var retryHandler = new MockRetryHandler();
var response = new HttpResponseMessage(feedResponseStatusCode);
if (!string.IsNullOrEmpty(feedResponseContentName))
{
var content = TestInputs.ReadAllBytes(Path.Combine("Nupkgs", $"{feedResponseContentName}.zip"));
response.Content = new ByteArrayContent(content);
}
;
var httpClient = FakeHttpClient.WithResponses(response);
var result = await GeneralUtils.CompareLocalPackageToFeedPackage(
localPackagePath,
packageContentUrl,
httpClient,
taskLoggingHelper,
retryHandler);
result.Should().Be(expectedResult);
}
[InlineData(HttpStatusCode.InternalServerError, 2)] // retry on 5xx
public async Task CompareLocalPackageToFeedPackageShouldRetryFailedRequests(
HttpStatusCode initialResponseStatusCode,
int expectedAttemptCount)
{
var testPackageName = Path.Combine("Nupkgs", "test-package-a.zip");
var localPackagePath = TestInputs.GetFullPath(testPackageName);
var packageContentUrl = "https://fakefeed.azure.com/nuget/v3/test-package-a.zip";
var taskLoggingHelper = new Microsoft.Build.Utilities.TaskLoggingHelper(new StubTask());
var retryHandler = new MockRetryHandler(maxAttempts: 2);
var responseContent = TestInputs.ReadAllBytes(testPackageName);
var responses = new[]
{
new HttpResponseMessage(initialResponseStatusCode)
{
Content = new ByteArrayContent(responseContent)
},
new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(responseContent)
}
};
var httpClient = FakeHttpClient.WithResponses(responses);
await GeneralUtils.CompareLocalPackageToFeedPackage(
localPackagePath,
packageContentUrl,
httpClient,
taskLoggingHelper,
retryHandler);
retryHandler.ActualAttempts.Should().Be(expectedAttemptCount);
}
public async void TrolleyCalculator_Serialize_Deserialize()
{
// Arrange
var expectedResult = new decimal(1);
var httpClient = FakeHttpClient.Create_WithContent(expectedResult.ToString(CultureInfo.InvariantCulture));
var trolleyTotalRequest = new TrolleyTotalRequest()
{
RequestedItems = new List <RequestedItem>()
{
new RequestedItem()
},
Specials = new List <Special>()
{
new Special()
{
Inventory = new List <SpecialInventory>()
{
new SpecialInventory()
}
}
},
Products = new List <Product>()
{
new Product()
}
};
var sut = new ResourceServiceHttpHttpClient(httpClient, _mockOptions);
// Act
var result = await sut.TrolleyCalculator(trolleyTotalRequest);
//Assert
Assert.Equal(expectedResult, result);
}
public async Task ParseAndExecuteDeploymentTasks_Success()
{
var client = new FakeHttpClient();
client.AddResponse("/network/networkDomain/d5791a6d-2b69-47e2-be06-f26a2ec4bff8", "NetworkDomain_Get.json");
client.AddResponse("/network/vlan?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test VLAN", "GenericNotFound.json");
client.AddResponse("/network/deployVlan", "Vlan_Delpoy.json");
client.AddResponse("/network/vlan/997e2084-00b1-4d1d-96ce-099946679c6f", "Vlan_Get.json");
client.AddResponse("/imageWithDiskSpeed?name=RedHat 6 64-bit 2 CPU", "Image_Get.xml");
client.AddResponse("/server/server?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&name=Unit Test Server", "GenericNotFound.json");
client.AddResponse("/server/deployServer", "Server_Deploy.json");
client.AddResponse("/server/server/b42b40e1-351a-4df9-b726-2ccff01f2767", "Server_Get.json");
client.AddResponse("/network/addPublicIpBlock", "PublicIpBlock_Add.json");
client.AddResponse("/network/publicIpBlock/996b066e-bdce-11e4-8c14-b8ca3a5d9ef8", "PublicIpBlock_Get.json");
client.AddResponse("/network/natRule?networkDomainId=d5791a6d-2b69-47e2-be06-f26a2ec4bff8&internalIp=10.0.0.8", "GenericNotFound.json");
client.AddResponse("/network/createNatRule", "NatRule_Create.json");
client.AddResponse("/network/natRule/a6b2e743-e330-4deb-a76e-0d9cb0b1d1bb", "NatRule_Get.json");
var templateFile = Path.Combine(_resourceFolder, "StandardTemplate.json");
var parametersFile = Path.Combine(_resourceFolder, "StandardTemplateParams.json");
var taskBuilder = new TaskBuilder();
var taskExecutor = taskBuilder.BuildTasksFromDeploymentTemplate(templateFile, parametersFile);
var log = await taskExecutor.Execute(_runtimeContext);
Assert.AreEqual(DeploymentLogStatus.Success, log.Status);
Assert.AreEqual("http://168.128.5.106/index.html", taskExecutor.Context.OutputParameters["ServerPublicUrl"]);
}
public async void GetShopperHistory_Serialize_Deserialize()
{
// Arrange
var expectedShopperHistoryDto = new ShopperHistoryDto()
{
CustomerId = 123,
Products = new List <ShopperHistoryProductDto>()
{
new ShopperHistoryProductDto()
{
Name = "a",
Price = 1,
Quantity = 2
}
}
};
var httpClient = FakeHttpClient.Create_WithContent("[{\"customerId\": 123,\"products\": [{\"name\": \"a\",\"price\": 1,\"quantity\": 2}]}]");
var sut = new ResourceServiceHttpHttpClient(httpClient, _mockOptions);
// Act
var result = await sut.GetShopperHistory();
//Assert
var shopperHistory = result.ToList();
Assert.True(shopperHistory.Count.Equals(1));
Assert.Equal(expectedShopperHistoryDto.CustomerId, shopperHistory.First().CustomerId);
Assert.True(shopperHistory.First().Products.Count.Equals(1));
Assert.Equal(expectedShopperHistoryDto.Products.First().Name, shopperHistory.First().Products.First().Name);
Assert.Equal(expectedShopperHistoryDto.Products.First().Price, shopperHistory.First().Products.First().Price);
Assert.Equal(expectedShopperHistoryDto.Products.First().Quantity, shopperHistory.First().Products.First().Quantity);
}
public async Task WhenGettingTheServerElasticubes_ShouldReturnThemWithTheCorrectInformation()
{
// Arrange
IHttpClient httpClient = new FakeHttpClient(responseMessageToReturn: CreateResponse());
IAuthenticator authenticator = new FakeAuthenticator();
var service = new ElastiCubesService("", httpClient, authenticator);
// Act
var result = await service.GetElastiCubesByServerAsync("myserver");
// Assert
Assert.Equal(2, result.Count());
Assert.Equal("9ef5aa670a32e20ae046c83f", result.First().Id);
Assert.Equal(DateTimeOffset.FromUnixTimeMilliseconds(1491905885118), result.First().CreatedUtc);
Assert.Equal("clients", result.First().DatabaseName);
Assert.Equal(DateTimeOffset.FromUnixTimeMilliseconds(1525312805480), result.First().LastBuiltUtc);
Assert.Equal(1, result.First().PermissionsSummary);
Assert.Equal(2.3436, result.First().SizeInMb);
Assert.Equal(ElastiCubeStatus.Stopped, result.First().Status);
Assert.Equal("clients", result.First().Title);
Assert.Null(result.First().Error);
Assert.False(result.First().Shares.First().BelongsToEveryoneGroup);
Assert.Equal("5422c7343cd8fa3410000001", result.First().Shares.First().PartyId);
Assert.Equal("w", result.First().Shares.First().Permission);
Assert.Equal("user", result.First().Shares.First().Type);
}
public void DownloadFileAsyncSucceedsForValidUrl()
{
var buildEngine = new MockBuildEngine();
var publishTask = new PublishArtifactsInManifestV3
{
BuildEngine = buildEngine,
};
var testFile = Path.Combine("Symbols", "test.txt");
var responseContent = TestInputs.ReadAllBytes(testFile);
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(responseContent)
};
using HttpClient client = FakeHttpClient.WithResponses(response);
var path = TestInputs.GetFullPath(Guid.NewGuid().ToString());
var test = publishTask.DownloadFileAsync(
client,
PublishArtifactsInManifestBase.ArtifactName.BlobArtifacts,
"1234",
"test.txt",
path);
Assert.True(File.Exists(path));
publishTask.DeleteTemporaryFiles(path);
publishTask.DeleteTemporaryDirectory(path);
}
public async Task ErrorContentOnErrorJson()
{
var message = FakeHttpClient.MessageResponse(HttpStatusCode.InsufficientStorage, "Throttled");
var exception = await Assert.ThrowsAsync <MeetupException>(() => message.AsObject <object>(MeetupClient.SetupOptions(null, null)));
Assert.Single(exception.Errors);
}
public void ConfigureFakeHttpClient(FakeHttpClient fakeHttpClient)
{
fakeHttpClient.UpdateResource(new FakeHttpResource(RecentFeedUri, RecentFeedResource));
fakeHttpClient.UpdateResource(new FakeHttpResource(Page1Uri, Archive1Resource));
fakeHttpClient.UpdateResource(new FakeHttpResource(Page2Uri, Archive2Resource));
fakeHttpClient.UpdateResource(new FakeHttpResource(Page3Uri, RecentFeedResource));
}
public ProvisioningProfileProviderTests()
{
_helpersMock = new Mock <IHelpers>();
_helpersMock
.Setup(x => x.DirectoryMutexExec(It.IsAny <Func <System.Threading.Tasks.Task> >(), It.IsAny <string>()))
.Callback <Func <System.Threading.Tasks.Task>, string>((function, path) => {
++_downloadCount;
function().GetAwaiter().GetResult();
});
_fileSystem = new MockFileSystem();
var response1 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("iOS content"),
};
var response2 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("tvOS content"),
};
var httpClient = FakeHttpClient.WithResponses(response1, response2);
_profileProvider = new ProvisioningProfileProvider(
new TaskLoggingHelper(new MockBuildEngine(), nameof(ProvisioningProfileProviderTests)),
_helpersMock.Object,
_fileSystem,
httpClient,
"https://netcorenativeassets.azure.com/profiles/{PLATFORM}.mobileprovision",
"/tmp");
}
public async Task FindTopicCategoriesUsesDataCorrectly()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("TopicCategory")
};
var meetup = MeetupClient.WithApiToken("TestToken", options);
var topics = await meetup.Topics.FindCategories();
Assert.NotNull(topics.Data);
Assert.Equal(3, topics.Data.Length);
var topic = topics.Data.Skip(1).First();
Assert.Equal("Tech", topic.Name);
Assert.Equal("tech", topic.ShortName);
Assert.Equal("Tech", topic.SortName);
Assert.Equal(292, topic.Id);
Assert.Single(topic.CategoryIds);
Assert.NotNull(topic.Photo);
Assert.Equal(450131949, topic.Photo.Id);
Assert.Equal(MeetupPhotoType.Event, topic.Photo.Type);
Assert.Equal("https://secure.meetupstatic.com/", topic.Photo.BaseUrl.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/highres_450131949.jpeg", topic.Photo.HighRes.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/600_450131949.jpeg", topic.Photo.Photo.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/thumb_450131949.jpeg", topic.Photo.Thumb.ToString());
}
protected void CreateHttpMocks(string responseContents)
{
httpMessageHandlerMock = FakeHttpClient.CreateHttpMessageHandler(responseContents);
HttpClient = httpMessageHandlerMock.ToHttpClient();
Mock.Get(HttpClientFactory).Setup(c => c.CreateClient()).Returns(HttpClient);
}
public async Task GetWithFieldsGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham?fields=plain_text_no_images_description")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Groups.Get("tech-nottingham", new [] { "plain_text_no_images_description" });
}
public async Task GetGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Groups.Get("tech-nottingham");
}
public void Initialize()
{
var httpClientFactory = Mock.Of <IHttpClientFactory>();
var httpClient = FakeHttpClient.CreateWithResponse(response);
Mock.Get(httpClientFactory).Setup(c => c.CreateClient()).Returns(() => httpClient);
dbProvider = new TestableDbProviderForExplain(TestParameters.KsqlDBUrl, httpClientFactory);
}
public override void TestInitialize()
{
base.TestInitialize();
HttpClientFactory = Mock.Of <IHttpClientFactory>();
HttpClient = FakeHttpClient.CreateWithResponse(StatementResponse);
Mock.Get(HttpClientFactory).Setup(c => c.CreateClient()).Returns(HttpClient);
}
public void Should_use_custom_http_client()
{
var fakeRequestCoordinator = A.Fake <IRequestCoordinator>();
var fakeHttpClient = new FakeHttpClient();
new FluentApi <Status>(fakeRequestCoordinator).UsingClient(fakeHttpClient);
Assert.That(fakeRequestCoordinator.HttpClient, Is.EqualTo(fakeHttpClient));
}
public void Should_use_custom_http_client()
{
var fakeRequestCoordinator = A.Fake<IRequestCoordinator>();
var fakeHttpClient = new FakeHttpClient();
new FluentApi<Status>(fakeRequestCoordinator).UsingClient(fakeHttpClient);
Assert.That(fakeRequestCoordinator.HttpClient, Is.EqualTo(fakeHttpClient));
}
public async Task FakeHttpClient_AllowsRulesWithStaticReturnValue()
{
var fakeClient = new FakeHttpClient();
fakeClient.AddRule(OkResponse);
var response200 = await fakeClient.GetAsync("http://www.404.com");
Assert.AreEqual(HttpStatusCode.OK, response200.StatusCode);
}
public void Validate_WithTwoInteractionsAndProviderStateSetupAndTearDownDefined_SetUpIsInvokedBeforeCompareAndTearDownIsInvokedAfterCompare()
{
const string providerState1 = "My Provider State";
const string providerState2 = "My Provider State 2";
const string setUpSuffix = "-SetUp";
const string tearDownSuffix = "-TearDown";
var actionInvocationLog = new List <string>();
var pact = new ProviderServicePactFile
{
Consumer = new Party {
Name = "My client"
},
Provider = new Party {
Name = "My Provider"
},
Interactions = new List <ProviderServiceInteraction>
{
new ProviderServiceInteraction
{
ProviderState = providerState1,
Description = "My interaction"
},
new ProviderServiceInteraction
{
ProviderState = providerState2,
Description = "My interaction"
},
}
};
var providerStates = new ProviderStates();
providerStates.Add(new ProviderState(providerState1, setUp: () => actionInvocationLog.Add(providerState1 + setUpSuffix), tearDown: () => actionInvocationLog.Add(providerState1 + tearDownSuffix)));
providerStates.Add(new ProviderState(providerState2, setUp: () => actionInvocationLog.Add(providerState2 + setUpSuffix), tearDown: () => actionInvocationLog.Add(providerState2 + tearDownSuffix)));
var mockProviderServiceResponseComparer = Substitute.For <IProviderServiceResponseComparer>();
var fakeHttpClient = new FakeHttpClient();
var mockHttpRequestMessageMapper = Substitute.For <IHttpRequestMessageMapper>();
var mockProviderServiceResponseMapper = Substitute.For <IProviderServiceResponseMapper>();
var providerServiceValidator = new ProviderServiceValidator(
mockProviderServiceResponseComparer,
fakeHttpClient,
mockHttpRequestMessageMapper,
mockProviderServiceResponseMapper,
new Reporter(new NoOpReportOutputter()));
providerServiceValidator.Validate(pact, providerStates);
Assert.Equal(4, actionInvocationLog.Count());
Assert.Equal(providerState1 + setUpSuffix, actionInvocationLog.First());
Assert.Equal(providerState1 + tearDownSuffix, actionInvocationLog.Skip(1).First());
Assert.Equal(providerState2 + setUpSuffix, actionInvocationLog.Skip(2).First());
Assert.Equal(providerState2 + tearDownSuffix, actionInvocationLog.Last());
}
public async Task CreateForGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham/venues?fields=taglist", System.Net.Http.HttpMethod.Post)
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.CreateFor("tech-nottingham", new Venue());
}
public async Task ForGroupGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham/venues?fields=taglist")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.For("tech-nottingham");
}
public async Task RecommendedVenueEmptyGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/recommended/venues?fields=taglist")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.Recommended();
}
public async Task FindTopicThrowsIfQueryIsEmpty()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topics?photo-host=public&query=tech")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Topics.Find(string.Empty));
}
public async Task ErrorContentOnClientReturningError()
{
var message = FakeHttpClient.MessageResponse(HttpStatusCode.InsufficientStorage, "Throttled");
var client = new HttpClient(new ActionMessageHandler(req => message));
var response = await client.GetAsync("https://test.com");
var exception = await Assert.ThrowsAsync <MeetupException>(() => response.AsObject <object>(MeetupClient.SetupOptions(null, null)));
Assert.Single(exception.Errors);
}
public async Task FindTopicUsesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topics?photo-host=public&query=tech")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Topics.Find("tech");
}
public async Task StatusCreatesCorrectCall()
{
var client = FakeHttpClient.AssertUrl("/status");
var defaults = new MeetupClientOptions
{
Client = client
};
var meetup = new MeetupClient(defaults);
await meetup.Meta.Status();
}
public async Task ServerImage_SubstituteTokensInString_NotFound()
{
var client = new FakeHttpClient();
client.AddResponse("/oec/0.9/base/imageWithDiskSpeed?name=RedHat 6 64-bit 2 CPU", "Image_Get_NotFound.xml");
var macro = new ImageMacro();
var input = "$serverImage['NA9', 'RedHat 6 64-bit 2 CPU']";
await macro.SubstituteTokensInString(_runtimeContext, null, input);
}
public async Task ShouldReturnCurrentFizzBuzzValue()
{
var client = new FakeHttpClient();
client.SetupGet("", new FizzBuzz(54));
var model = await new FizzBuzz(client: client).GetCurrent();
Assert.Equal(54, model.Value);
}
public async Task FakeHttpClient_KeepsRequestHistory()
{
var fakeClient = new FakeHttpClient();
fakeClient.AddRule(OkResponse);
var response404 = await fakeClient.GetAsync("http://www.404.com");
var response200 = await fakeClient.GetAsync("http://www.200.com");
Assert.AreEqual(2, fakeClient.History.Count);
}
public async Task FakeHttpClient_AllowsRulesWithConditionalReturnValue()
{
var fakeClient = new FakeHttpClient();
fakeClient.AddRule(req => req.RequestUri.Host == "www.404.com" ? NotFound : OkResponse);
var response404 = await fakeClient.GetAsync("http://www.404.com");
var response200 = await fakeClient.GetAsync("http://www.200.com");
Assert.AreEqual(HttpStatusCode.NotFound, response404.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response200.StatusCode);
}
public async Task FakeHttpClient_AllowsRulesWithUnconditionalReturnValue()
{
var fakeClient = new FakeHttpClient();
fakeClient.AddRule(r => r.RequestUri.Host == "www.200.com", OkResponse);
fakeClient.AddRule(r => r.RequestUri.Host == "www.500.com", ErrorResponse);
fakeClient.AddRule(r => r.RequestUri.Host == "www.404.com", NotFound);
var response404 = await fakeClient.GetAsync("http://www.404.com");
var response200 = await fakeClient.GetAsync("http://www.200.com");
var response500 = await fakeClient.GetAsync("http://www.500.com");
Assert.AreEqual(HttpStatusCode.NotFound, response404.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response200.StatusCode);
Assert.AreEqual(HttpStatusCode.InternalServerError, response500.StatusCode);
}
public void Should_throw_if_http_error()
{
var projectionName = Guid.NewGuid().ToString();
var projectionContent = Guid.NewGuid().ToString();
var response = new HttpResponse(HttpStatusCode.InternalServerError, String.Empty, String.Empty);
var httpClient = new FakeHttpClient(u => response, (u, d) => response, (u, d) => response);
var counter = new CountdownEvent(1);
httpClient.SetCounter(counter);
var manager = new ProjectionsManager(EventStoreAddress, httpClient);
manager.GetConfigAsync(projectionName);
Assert.IsTrue(counter.Wait(3000));
}
public void Should_update_existing_projection()
{
var projectionName = Guid.NewGuid().ToString();
var projectionContent = Guid.NewGuid().ToString();
var httpClient = new FakeHttpClient(u => new HttpResponse(HttpStatusCode.OK, String.Empty, String.Empty), null, null);
var manager = new ProjectionsManager(EventStoreAddress, httpClient);
var counter = new CountdownEvent(1);
httpClient.SetCounter(counter);
manager.UpdateProjectionQueryAsync(projectionName, projectionContent);
Assert.IsTrue(counter.Wait(3000));
CollectionAssert.IsEmpty(httpClient.PostRequests);
CollectionAssert.IsEmpty(httpClient.GetRequests);
CollectionAssert.IsNotEmpty(httpClient.PutRequests);
StringAssert.Contains(projectionName, httpClient.PutRequests[0].Url);
}
public void Should_return_xmlnode_if_valid_xml_received_using_async()
{
var fakeClient = new FakeHttpClient(new Response
{
StatusCode = HttpStatusCode.OK,
Body = SERVICE_STATUS
});
var endpointResolver = new RequestCoordinator(fakeClient, _urlSigner, EssentialDependencyCheck<IOAuthCredentials>.Instance, EssentialDependencyCheck<IApiUri>.Instance);
var reset = new AutoResetEvent(false);
string response = string.Empty;
endpointResolver.HitEndpointAsync(new EndPointInfo(),
s =>
{
response = s.Body;
reset.Set();
});
reset.WaitOne(1000 * 5);
var payload = new XmlDocument();
payload.LoadXml(response);
Assert.That(payload.HasChildNodes);
Assert.That(payload.SelectSingleNode("//serverTime"), Is.Not.Null);
}
public void ConfigureFakeHttpClient(FakeHttpClient fakeHttpClient)
{
fakeHttpClient.UpdateResource(new FakeHttpResource(RecentFeedUri, RecentFeedResource));
}
public async Task FakeHttpClient_ThrowsExceptionWhenFakeReturnsNull()
{
var fakeClient = new FakeHttpClient();
fakeClient.AddRule(r => null);
var response = await fakeClient.GetAsync("http://www.test.com");
}
public async Task FakeHttpClient_ThrowsExceptionWhenFakeIsNotSetup()
{
var fakeClient = new FakeHttpClient();
var response = await fakeClient.GetAsync("http://www.test.com");
}
