public void TestGatewayAddressCacheAutoRefreshOnSuboptimalPartition()
{
FakeMessageHandler messageHandler = new FakeMessageHandler();
HttpClient httpClient = new HttpClient(messageHandler);
httpClient.Timeout = TimeSpan.FromSeconds(120);
GatewayAddressCache cache = new GatewayAddressCache(
new Uri(GatewayAddressCacheTests.DatabaseAccountApiEndpoint),
Documents.Client.Protocol.Https,
this.mockTokenProvider.Object,
this.mockServiceConfigReader.Object,
MockCosmosUtil.CreateCosmosHttpClient(() => httpClient),
suboptimalPartitionForceRefreshIntervalInSeconds: 2);
int initialAddressesCount = cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
false,
CancellationToken.None).Result.AllAddresses.Count();
Assert.IsTrue(initialAddressesCount < this.targetReplicaSetSize);
Task.Delay(3000).Wait();
int finalAddressCount = cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
false,
CancellationToken.None).Result.AllAddresses.Count();
Assert.IsTrue(finalAddressCount == this.targetReplicaSetSize);
}
public async Task ComponentShouldSetDraftIfEntryIsNull()
{
//Arrange
var handler = new FakeMessageHandler();
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.NotFound, Content = new StringContent(@"{""sys"":{""type"":""Array""},""total"":0,""skip"":0,""limit"":100,""items"":[]}")
});
var httpClient = new HttpClient(handler);
var optionsManager = new Mock <IContentfulOptionsManager>();
optionsManager.SetupGet(c => c.Options).Returns(new ContentfulOptions());
var component = new EntryStateViewComponent(httpClient, optionsManager.Object);
var sysProperties = new List <SystemProperties> {
new SystemProperties {
Id = "434"
}
};
//Act
var res = await component.InvokeAsync(sysProperties);
//Assert
Assert.IsType <ViewViewComponentResult>(res);
Assert.True(((res as ViewViewComponentResult).ViewData.Model as EntryStateModel).Draft);
}
public async Task falls_back_to_first_alive_node_if_a_preferred_node_is_not_found()
{
var gossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 1111,
IsAlive = false,
},
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Follower,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 2222,
IsAlive = true,
},
}
};
var handler = new FakeMessageHandler(req => ResponseFromGossip(gossip));
var sut = new ClusterEndpointDiscoverer(1, new[] {
new DnsEndPoint("localhost", 1113)
}, Timeout.InfiniteTimeSpan, TimeSpan.Zero, NodePreference.Leader, handler);
var result = await sut.DiscoverAsync();
Assert.Equal(result.Port,
gossip.Members.Last(x => x.State == ClusterMessages.VNodeState.Follower).ExternalHttpPort);
}
public async Task ComponentShouldSetPendingChangesIfUpdatedAtDoesNotMatch()
{
//Arrange
var handler = new FakeMessageHandler();
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK, Content = new StringContent(@"{""sys"":{""type"":""Array""},""total"":0,""skip"":0,""limit"":100,""items"":[{""sys"": {""updatedAt"":""2017-10-01""}, ""fields"": {""test"": ""pop""}}]}")
});
var httpClient = new HttpClient(handler);
var optionsManager = new Mock <IContentfulOptionsManager>();
optionsManager.SetupGet(c => c.Options).Returns(new ContentfulOptions());
var component = new EntryStateViewComponent(httpClient, optionsManager.Object);
var sysProperties = new SystemProperties();
sysProperties.UpdatedAt = new DateTime(2017, 11, 03);
sysProperties.Id = "123";
//Act
var res = await component.InvokeAsync(new[] { sysProperties });
//Assert
Assert.IsType <ViewViewComponentResult>(res);
Assert.True(((res as ViewViewComponentResult).ViewData.Model as EntryStateModel).PendingChanges);
}
public async Task should_issue_gossip_to_gossip_seed()
{
HttpRequestMessage request = null;
var gossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 4444,
IsAlive = true,
},
}
};
var handler = new FakeMessageHandler(req => {
request = req;
return(ResponseFromGossip(gossip));
});
var gossipSeed = new DnsEndPoint("gossip_seed_endpoint", 1114);
var sut = new ClusterEndpointDiscoverer(1, new[] {
gossipSeed,
}, Timeout.InfiniteTimeSpan, TimeSpan.Zero, NodePreference.Leader, handler);
await sut.DiscoverAsync();
Assert.Equal(Uri.UriSchemeHttps, request?.RequestUri.Scheme);
Assert.Equal(gossipSeed.Host, request?.RequestUri.Host);
Assert.Equal(gossipSeed.Port, request?.RequestUri.Port);
}
public async Task FetchAsync_Sends_Valid_Json_Request()
{
// arrange
var messageHandler = new FakeMessageHandler();
var httpClient = new HttpClient(messageHandler)
{
BaseAddress = new Uri("http://some.url")
};
IReadOnlyQueryRequest query = QueryRequestBuilder.New()
.SetQuery(
@"query aQuery {
foo
bar
}")
.AddVariableValue("strVar", new StringValueNode("some-string"))
.AddVariableValue("intVal", new IntValueNode(42))
.AddVariableValue("floatVal", new FloatValueNode(1.23m))
.AddVariableValue("boolVal", new BooleanValueNode(true))
.AddVariableValue("listVal",
new ListValueNode(
new ReadOnlyCollection <FloatValueNode>(
new List <FloatValueNode>
{
new FloatValueNode(1.23m),
new FloatValueNode(1.80m),
new FloatValueNode(2.80m)
})))
.AddVariableValue("listStringVal",
new ListValueNode(
new ReadOnlyCollection <StringValueNode>(
new List <StringValueNode>
{
new StringValueNode("a"),
new StringValueNode("b"),
new StringValueNode("c")
})))
.AddVariableValue("enumVal", new EnumValueNode(System.Net.HttpStatusCode.OK))
.AddVariableValue("otherStrVar", new StringValueNode("some-other-string"))
.Create();
// act
await sut.FetchAsync(
query,
httpClient);
// assert
try
{
dynamic requestObj = JsonConvert.DeserializeObject(messageHandler.requestBody);
Assert.NotNull(requestObj);
Assert.NotNull(requestObj.query);
Assert.NotNull(requestObj.variables);
}
catch (Exception e)
{
Assert.True(false, $"Unable to parse request as json: {e.Message}");
}
}
public async Task ApiKey_NoOtherCredentials_QuotaProject()
{
var builder = new SampleClientBuilder
{
ApiKey = SampleApiKey,
QuotaProject = SampleQuotaProject
};
Action <BaseClientService.Initializer> validator = initializer =>
{
Assert.Equal(SampleApiKey, initializer.ApiKey);
Assert.NotNull(initializer.HttpClientInitializer);
var quotaProjectInitializer = initializer.HttpClientInitializer;
using var handler = new FakeMessageHandler();
using var client = new ConfigurableHttpClient(new ConfigurableMessageHandler(handler));
quotaProjectInitializer.Initialize(client);
client.GetAsync("https://will.be.ignored").Wait();
var header = Assert.Single(handler.LatestRequestHeaders, header => header.Key == "x-goog-user-project");
var value = Assert.Single(header.Value);
Assert.Equal(SampleQuotaProject, value);
};
await ValidateResultAsync(builder, validator);
}
private static FluentClient CreateClient(FakeResponseMode mode = FakeResponseMode.Capture)
{
var serializer = new JsonContentSerializer();
var fakeHttp = new FakeMessageHandler {
Mode = mode
};
var client = new FluentClient(serializer, fakeHttp);
return(client);
}
private static FluentClient CreateClient()
{
var serializer = new JsonContentSerializer();
var fakeStore = MemoryMessageStore.Current;
var fakeHttp = new FakeMessageHandler(fakeStore, FakeResponseMode.Fake);
var client = new FluentClient(serializer, fakeHttp);
client.BaseUri = new Uri("http://httpbin.org/", UriKind.Absolute);
return(client);
}
public async Task DeeplinkerShouldAddContentfulOptionsFromQuery()
{
//Arrange
var optionsManager = new Mock <IContentfulOptionsManager>();
optionsManager.SetupGet(c => c.Options).Returns(new ContentfulOptions {
DeliveryApiKey = "Fasanhöns"
});
var deeplinker = new Deeplinker((innerHttpContext) =>
{
return(Task.CompletedTask);
}, optionsManager.Object);
var mockSession = new Mock <ISession>();
mockSession.Setup(c => c.Set(nameof(ContentfulOptions), It.IsAny <byte[]>())).Verifiable();
var mockQuery = new Mock <IQueryCollection>();
mockQuery.Setup(c => c.ContainsKey(It.Is <string>(s => s == "space_id" || s == "preview_token" || s == "delivery_token"))).Returns(true);
mockQuery.SetupGet(c => c["delivery_token"]).Returns("McKinley");
mockQuery.SetupGet(c => c["space_id"]).Returns("Kilimanjaro");
mockQuery.SetupGet(c => c["preview_token"]).Returns("Fuji");
var mockRequest = new Mock <HttpRequest>();
mockRequest.SetupGet(r => r.Query).Returns(mockQuery.Object);
var handler = new FakeMessageHandler();
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK, Content = new StringContent(@"{""sys"":{""type"":""Array""},""total"":0,""skip"":0,""limit"":100,""items"":[]}")
});
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK, Content = new StringContent(@"{""sys"":{""type"":""Array""},""total"":0,""skip"":0,""limit"":100,""items"":[]}")
});
var httpClient = new HttpClient(handler);
var mockProvider = new Mock <IServiceProvider>();
mockProvider.Setup(c => c.GetService(typeof(HttpClient))).Returns(httpClient);
var mockContext = new Mock <HttpContext>();
mockContext.Setup(c => c.Session).Returns(mockSession.Object);
mockContext.SetupGet(c => c.Request).Returns(mockRequest.Object);
mockContext.SetupGet(c => c.RequestServices).Returns(mockProvider.Object);
//Act
await deeplinker.Invoke(mockContext.Object);
//Assert
mockSession.Verify(c => c.Set(nameof(ContentfulOptions), It.Is <byte[]>(b => Encoding.UTF8.GetString(b).Contains("McKinley"))));
}
public async Task GetAsync()
{
var init = Substitute.For<IHttpInitializer>();
var messager = new FakeMessageHandler(new HttpResponseMessage());
init.HttpClient.Returns(new HttpClient(messager));
var rest = new RestClient(init);
var config = new HttpConfiguration(new Uri("http://happy.ca/"), "route", HttpRequest.Get);
var ads = await rest.GetAsync(config, response => new List<Ad>{new Ad{AdID = Int32.MaxValue}});
Assert.AreEqual(1, ads.Count(x=>x.AdID==Int32.MaxValue));
Assert.AreEqual("http://happy.ca/route", messager.RequestMessage.RequestUri.AbsoluteUri);
Assert.AreEqual(HttpMethod.Get, messager.RequestMessage.Method);
}
public async Task should_pick_node_based_on_preference(NodePreference preference,
ClusterMessages.VNodeState expectedState)
{
var gossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 1111,
IsAlive = true,
},
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Follower,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 2222,
IsAlive = true,
},
new ClusterMessages.MemberInfo {
State = expectedState == ClusterMessages.VNodeState.ReadOnlyLeaderless
? expectedState
: ClusterMessages.VNodeState.ReadOnlyReplica,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 3333,
IsAlive = true,
},
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Manager,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 4444,
IsAlive = true,
},
}
};
var handler = new FakeMessageHandler(req => ResponseFromGossip(gossip));
var sut = new ClusterEndpointDiscoverer(1, new[] {
new DnsEndPoint("localhost", 1113)
}, Timeout.InfiniteTimeSpan, TimeSpan.Zero, preference, handler);
var result = await sut.DiscoverAsync();
Assert.Equal(result.Port,
gossip.Members.Last(x => x.State == expectedState).ExternalHttpPort);
}
public async Task GatewayAddressCacheInNetworkRequestTestAsync()
{
FakeMessageHandler messageHandler = new FakeMessageHandler();
HttpClient httpClient = new HttpClient(messageHandler);
httpClient.Timeout = TimeSpan.FromSeconds(120);
GatewayAddressCache cache = new GatewayAddressCache(
new Uri(GatewayAddressCacheTests.DatabaseAccountApiEndpoint),
Documents.Client.Protocol.Https,
this.mockTokenProvider.Object,
this.mockServiceConfigReader.Object,
MockCosmosUtil.CreateCosmosHttpClient(() => httpClient),
suboptimalPartitionForceRefreshIntervalInSeconds: 2,
enableTcpConnectionEndpointRediscovery: true);
// No header should be present.
PartitionAddressInformation legacyRequest = await cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
false,
CancellationToken.None);
Assert.IsFalse(legacyRequest.IsLocalRegion);
// Header indicates the request is from the same azure region.
messageHandler.Headers[HttpConstants.HttpHeaders.LocalRegionRequest] = "true";
PartitionAddressInformation inNetworkAddresses = await cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
true,
CancellationToken.None);
Assert.IsTrue(inNetworkAddresses.IsLocalRegion);
// Header indicates the request is not from the same azure region.
messageHandler.Headers[HttpConstants.HttpHeaders.LocalRegionRequest] = "false";
PartitionAddressInformation outOfNetworkAddresses = await cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
true,
CancellationToken.None);
Assert.IsFalse(outOfNetworkAddresses.IsLocalRegion);
}
private static FluentClient CreateClient()
{
var serializer = new JsonContentSerializer();
var fakeStore = new FileMessageStore();
fakeStore.StorePath = @".\GitHub\Responses";
var fakeHttp = new FakeMessageHandler(fakeStore, FakeResponseMode.Fake);
var client = new FluentClient(serializer, fakeHttp);
client.BaseUri = new Uri("https://api.github.com/", UriKind.Absolute);
return(client);
}
public async Task CanRegisterSubscriptions()
{
var composer = new ServiceBusComposer();
var fakeMessageHandler = new FakeMessageHandler();
composer.WithAdditionalServices(services =>
{
services.AddSingleton(fakeMessageHandler);
services.ConfigureServiceBus(options =>
{
options
.RegisterSubscription("testTopic", "testsubscription001")
.WithConnectionString("testConnectionString")
.WithCustomMessageHandler <FakeMessageHandler>();
options
.RegisterSubscription("testTopic", "testsubscription002")
.WithConnectionString("testConnectionString")
.WithCustomMessageHandler <FakeMessageHandler>();
});
});
var provider = await composer.ComposeAndSimulateStartup();
var clients = provider.GetRequiredService <FakeSubscriptionClientFactory>().GetAllRegisteredSubscriptionClients();
var message = new Message();
foreach (var client in clients)
{
await client.TriggerMessageReception(message, CancellationToken.None);
}
fakeMessageHandler.Mock.Verify(
o => o.HandleMessageAsync(
It.Is <MessageContext>(
context => context.Message == message &&
context.Receiver.Name == "testTopic/Subscriptions/testsubscription001")),
Times.Once);
fakeMessageHandler.Mock.Verify(
o => o.HandleMessageAsync(
It.Is <MessageContext>(
context => context.Message == message &&
context.Receiver.Name == "testTopic/Subscriptions/testsubscription002")),
Times.Once);
}
public void GlobalAddressResolverUpdateAsyncSynchronizationTest()
{
SynchronizationContext prevContext = SynchronizationContext.Current;
try
{
TestSynchronizationContext syncContext = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
syncContext.Post(_ =>
{
UserAgentContainer container = new UserAgentContainer(clientId: 0);
FakeMessageHandler messageHandler = new FakeMessageHandler();
AccountProperties databaseAccount = new AccountProperties();
Mock <IDocumentClientInternal> mockDocumentClient = new Mock <IDocumentClientInternal>();
mockDocumentClient.Setup(owner => owner.ServiceEndpoint).Returns(new Uri("https://blabla.com/"));
mockDocumentClient.Setup(owner => owner.GetDatabaseAccountInternalAsync(It.IsAny <Uri>(), It.IsAny <CancellationToken>())).ReturnsAsync(databaseAccount);
GlobalEndpointManager globalEndpointManager = new GlobalEndpointManager(mockDocumentClient.Object, new ConnectionPolicy());
GlobalPartitionEndpointManager partitionKeyRangeLocationCache = new GlobalPartitionEndpointManagerCore(globalEndpointManager);
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
RequestTimeout = TimeSpan.FromSeconds(10)
};
GlobalAddressResolver globalAddressResolver = new GlobalAddressResolver(
endpointManager: globalEndpointManager,
partitionKeyRangeLocationCache: partitionKeyRangeLocationCache,
protocol: Documents.Client.Protocol.Tcp,
tokenProvider: this.mockTokenProvider.Object,
collectionCache: null,
routingMapProvider: null,
serviceConfigReader: this.mockServiceConfigReader.Object,
connectionPolicy: connectionPolicy,
httpClient: MockCosmosUtil.CreateCosmosHttpClient(() => new HttpClient(messageHandler)));
ConnectionStateListener connectionStateListener = new ConnectionStateListener(globalAddressResolver);
connectionStateListener.OnConnectionEvent(ConnectionEvent.ReadEof, DateTime.Now, new Documents.Rntbd.ServerKey(new Uri("https://endpoint.azure.com:4040/")));
}, state: null);
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevContext);
}
}
public async Task Query_WhenInvalidUri_Returns404()
{
ConfigContextBase.SearchUris.Add(new FailureCountingUri("http://10.141.151.101:8091/"));
var fakeMessageHandler = new FakeMessageHandler
{
StatusCode = HttpStatusCode.NotFound,
Content = new StringContent("Requested resource not found. ")
};
var client = new SearchClient(new HttpClient(fakeMessageHandler), new SearchDataMapper());
var response = await client.QueryAsync(new SearchQuery
{
Index = "indexdoesnotexist",
Query = new MatchQuery("foo")
});
Assert.IsTrue(response.Exception.Message.Contains("404"));
}
public async Task QueryAsync_WhenInvalidIndexName_Returns403()
{
ConfigContextBase.SearchUris.Add(new FailureCountingUri("http://10.141.151.101:8091/"));
var fakeMessageHandler = new FakeMessageHandler
{
StatusCode = HttpStatusCode.Forbidden,
Content = new StringContent("rest_auth: preparePerm, err: index not found ")
};
var client = new SearchClient(new HttpClient(fakeMessageHandler), new SearchDataMapper());
var response = await client.QueryAsync(new SearchQuery
{
Index = "indexdoesnotexist",
Query = new MatchQuery("foo")
});
Assert.IsTrue(response.Exception.Message.Contains("403"));
}
public async Task should_not_exceed_max_discovery_attempts()
{
int maxDiscoveryAttempts = 5;
int discoveryAttempts = 0;
var handler = new FakeMessageHandler(request => {
discoveryAttempts++;
throw new Exception();
});
var sut = new ClusterEndpointDiscoverer(maxDiscoveryAttempts, new[] {
new DnsEndPoint("localhost", 1114),
}, Timeout.InfiniteTimeSpan, TimeSpan.Zero, NodePreference.Leader, handler);
await Assert.ThrowsAsync <DiscoveryException>(() => sut.DiscoverAsync());
Assert.Equal(maxDiscoveryAttempts, discoveryAttempts);
}
public async Task should_not_be_able_to_pick_invalid_node(ClusterMessages.VNodeState invalidState)
{
var gossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = invalidState,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 4444,
IsAlive = true,
},
}
};
var handler = new FakeMessageHandler(req => ResponseFromGossip(gossip));
var sut = new ClusterEndpointDiscoverer(1, new[] { new DnsEndPoint("localhost", 1113), }, Timeout.InfiniteTimeSpan, TimeSpan.Zero, NodePreference.Leader, handler);
await Assert.ThrowsAsync <DiscoveryException>(() => sut.DiscoverAsync());
}
public void ThenResponseContentIsComposedByAllFieldsWithValue(int id)
{
//arrange
var responseObject = new Post()
{
Id = 2, Body = "2", Title = "2", UserId = "2"
};
MemoryMessageStore.Current.Register(b => b
.Url($"{apiUrl}/posts/{id}")
.StatusCode(HttpStatusCode.OK)
.ReasonPhrase("OK")
.Content(c => c
.Header("Content-Type", "application/json; charset=utf-8")
.Data(responseObject) // object to be JSON serialized
)
);
// use memory store by default
var serializer = new JsonContentSerializer();
var fakeHttp = new FakeMessageHandler();
var client = new FluentClient(serializer, fakeHttp);
client.BaseUri = new Uri(apiUrl, UriKind.Absolute);
//act
response = client.GetAsync(b => b
.AppendPath("posts")
.AppendPath(id.ToString())).Result;
//assert
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
result = response.DeserializeAsync <Post>().Result;
Assert.NotNull(result);
Assert.AreEqual(id, result.Id);
Assert.AreEqual(id.ToString(), result.Title);
Assert.AreEqual(id.ToString(), result.UserId);
Assert.AreEqual(id.ToString(), result.Body);
}
public async Task CustomMessageHandlerCanReceiveMessages()
{
var composer = new ServiceBusComposer();
var fakeMessageHandler = new FakeMessageHandler();
composer.WithAdditionalServices(
services =>
{
services.AddSingleton(fakeMessageHandler);
services.ConfigureServiceBus(
options =>
{
options
.RegisterSubscription("testTopic", "testSub")
.WithConnectionString("connectionStringTest")
.WithCustomMessageHandler <FakeMessageHandler>();
});
});
var provider = await composer.ComposeAndSimulateStartup();
var clientMock = provider.GetSubscriptionClientMock("testSub");
var sentMessage = new Message();
var sentToken = new CancellationToken();
await clientMock.TriggerMessageReception(sentMessage, sentToken);
fakeMessageHandler.Mock
.Verify(
o => o.HandleMessageAsync(
It.Is <MessageContext>(
context => context.Message == sentMessage &&
context.Receiver.Name == "testTopic/Subscriptions/testSub" &&
context.Token == sentToken)),
Times.Once);
}
public async Task TestGatewayAddressCacheUpdateOnConnectionResetAsync()
{
FakeMessageHandler messageHandler = new FakeMessageHandler();
HttpClient httpClient = new HttpClient(messageHandler);
httpClient.Timeout = TimeSpan.FromSeconds(120);
GatewayAddressCache cache = new GatewayAddressCache(
new Uri(GatewayAddressCacheTests.DatabaseAccountApiEndpoint),
Documents.Client.Protocol.Https,
this.mockTokenProvider.Object,
this.mockServiceConfigReader.Object,
MockCosmosUtil.CreateCosmosHttpClient(() => httpClient),
suboptimalPartitionForceRefreshIntervalInSeconds: 2,
enableTcpConnectionEndpointRediscovery: true);
PartitionAddressInformation addresses = cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
false,
CancellationToken.None).Result;
Assert.IsNotNull(addresses.AllAddresses.Select(address => address.PhysicalUri == "https://blabla.com"));
// call updateAddress
await cache.TryRemoveAddressesAsync(new Documents.Rntbd.ServerKey(new Uri("https://blabla.com")), CancellationToken.None);
// check if the addresss is updated
addresses = cache.TryGetAddressesAsync(
DocumentServiceRequest.Create(OperationType.Invalid, ResourceType.Address, AuthorizationTokenType.Invalid),
this.testPartitionKeyRangeIdentity,
this.serviceIdentity,
false,
CancellationToken.None).Result;
Assert.IsNotNull(addresses.AllAddresses.Select(address => address.PhysicalUri == "https://blabla5.com"));
}
public async Task CustomMessageHandlerWontReceiveMessagesWhenDeactivated()
{
var services = new ServiceCollection();
services.AddLogging();
services.AddServiceBus(true, false);
services.OverrideClientFactories();
var fakeMessageHandler = new FakeMessageHandler();
services.AddSingleton(fakeMessageHandler);
services.ConfigureServiceBus(
options =>
{
options
.RegisterSubscription("testTopic", "testSub")
.WithConnectionString("connectionStringTest")
.WithCustomMessageHandler <FakeMessageHandler>();
});
var provider = services.BuildServiceProvider();
await provider.SimulateStartHost(token : new CancellationToken());
var clientMock = provider.GetSubscriptionClientMock("testSub");
var sentMessage = new Message();
var sentToken = new CancellationToken();
await clientMock.TriggerMessageReception(sentMessage, sentToken);
fakeMessageHandler.Mock
.Verify(
o => o.HandleMessageAsync(
It.Is <MessageContext>(
context => context.Message == sentMessage &&
context.Receiver.Name == "testQueue" &&
context.Token == sentToken)),
Times.Never);
}
public void DeploymentManagerExtensibility()
{
// Arrange
string repositoryName = "Mvc3Application";
string appName = KuduUtils.GetRandomWebsiteName("DeploymentApis");
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
var handler = new FakeMessageHandler()
{
InnerHandler = new HttpClientHandler()
};
var manager = new RemoteDeploymentManager(appManager.DeploymentManager.ServiceUrl, handler);
manager.Credentials = appManager.DeploymentManager.Credentials;
var results = manager.GetResultsAsync().Result.ToList();
Assert.Equal(0, results.Count);
Assert.NotNull(handler.Url);
});
}
}
public void SetUp()
{
handler = new FakeMessageHandler();
service = new GitHubService(handler);
}
public RestApiClientBuilder()
{
_fakeHandler = new FakeMessageHandler();
}
public void SetUp()
{
handler = new FakeMessageHandler();
service = new GitHubService(handler);
}
public async Task should_be_able_to_discover_twice()
{
bool isFirstGossip = true;
var firstGossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 1111,
IsAlive = true,
},
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Follower,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 2222,
IsAlive = true,
},
}
};
var secondGossip = new ClusterMessages.ClusterInfo {
Members = new[] {
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 1111,
IsAlive = false,
},
new ClusterMessages.MemberInfo {
State = ClusterMessages.VNodeState.Leader,
InstanceId = Guid.NewGuid(),
ExternalHttpIp = IPAddress.Any.ToString(),
ExternalHttpPort = 2222,
IsAlive = true,
},
}
};
var handler = new FakeMessageHandler(req => {
if (isFirstGossip)
{
isFirstGossip = false;
return(ResponseFromGossip(firstGossip));
}
else
{
return(ResponseFromGossip(secondGossip));
}
});
var gossipSeed = new DnsEndPoint("gossip_seed_endpoint", 1114);
var sut = new ClusterEndpointDiscoverer(5, new[] {
gossipSeed,
}, Timeout.InfiniteTimeSpan, TimeSpan.Zero, NodePreference.Leader, handler);
var result = await sut.DiscoverAsync();
var expected = firstGossip.Members.First(x => x.ExternalHttpPort == 1111);
Assert.Equal(expected.ExternalHttpIp, result.Address.ToString());
Assert.Equal(expected.ExternalHttpPort, result.Port);
result = await sut.DiscoverAsync();
expected = secondGossip.Members.First(x => x.ExternalHttpPort == 2222);
Assert.Equal(expected.ExternalHttpIp, result.Address.ToString());
Assert.Equal(expected.ExternalHttpPort, result.Port);
}
public async Task Query_WhenInvalidUri_MaxScoreIsZero()
{
ConfigContextBase.SearchUris.Add(new FailureCountingUri("http://10.141.151.101:8091/"));
var fakeMessageHandler = new FakeMessageHandler
{
StatusCode = HttpStatusCode.NotFound,
Content = new StringContent("Requested resource not found. ")
};
var client = new SearchClient(new HttpClient(fakeMessageHandler), new SearchDataMapper());
var response = await client.QueryAsync(new SearchQuery
{
Index = "indexdoesnotexist",
Query = new MatchQuery("foo")
});
Assert.AreEqual(0, response.Metrics.MaxScore);
}
