public void GetUsers_Builds_Correct_Uri()
{
const string expectedFormValueString = "http://localhost:8091/settings/rbac/users/local";
var handler = FakeHttpMessageHandler.Create(request =>
{
Assert.AreEqual(expectedFormValueString, request.RequestUri.OriginalString);
Assert.AreEqual(HttpMethod.Get, request.Method);
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("")
};
return(response);
});
var client = new HttpClient(handler);
var clientConfig = new ClientConfiguration();
var serverConfigMock = new Mock <IServerConfig>();
var dataMapper = new JsonDataMapper(clientConfig);
var manager = new ClusterManager(clientConfig, serverConfigMock.Object, dataMapper, client, "username", "password");
manager.GetUsers(AuthenticationDomain.Local);
}
public async Task PrepareAsync_Sets_LastActivity()
{
ConfigContextBase.QueryUris.Add(new FailureCountingUri("http://localhost"));
var httpClient = new HttpClient(
FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK))
);
var config = new ClientConfiguration();
var client = new QueryClient(
httpClient,
new JsonDataMapper(config),
config,
new ConcurrentDictionary <string, QueryPlan>()
);
Assert.IsNull(client.LastActivity);
var queryRequest = new QueryRequest("SELECT * FROM `default`;");
await client.PrepareAsync(queryRequest, CancellationToken.None);
Assert.IsNotNull(client.LastActivity);
}
public void UpsertUser_Builds_Correct_Uri()
{
const string expectedFormValueString = "http://localhost:8091/settings/rbac/users/local/alice";
var handler = FakeHttpMessageHandler.Create(request =>
{
Assert.AreEqual(expectedFormValueString, request.RequestUri.OriginalString);
Assert.AreEqual(HttpMethod.Put, request.Method);
return(new HttpResponseMessage(HttpStatusCode.OK));
});
var client = new HttpClient(handler);
var clientConfig = new ClientConfiguration();
var serverConfigMock = new Mock <IServerConfig>();
var dataMapper = new JsonDataMapper(clientConfig);
var manager = new ClusterManager(clientConfig, serverConfigMock.Object, dataMapper, client, "username", "password");
manager.UpsertUser(AuthenticationDomain.Local, "alice", "secure123", "Alice Liddell", new Role {
Name = "Admin"
}, new Role {
Name = "BucketManager", BucketName = "default"
});
}
public void Flush_WhenFails_ReturnsFailure()
{
// Arrange
var handler = FakeHttpMessageHandler.Create(request =>
new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent("response")
});
var managerMock = new Mock <BucketManager>(_mockBucket, _clientConfiguration,
new JsonDataMapper(_clientConfiguration), new HttpClient(handler), "username", "password");
managerMock.Setup(x => x.FlushAsync()).CallBase();
// Act
var result = managerMock.Object.Flush();
// Assert
Assert.IsFalse(result.Success);
}
public async Task ExecuteAsync_Sets_LastActivity()
{
var handler = FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{ }")
});
var httpClient = new HttpClient(handler);
var httpClientFactory = new MockHttpClientFactory(httpClient);
var serializer = new DefaultSerializer();
var queryClient = new ViewClient(httpClientFactory, serializer, new Mock <ILogger <ViewClient> >().Object,
new Mock <IRedactor>().Object, NoopRequestTracer.Instance);
Assert.Null(queryClient.LastActivity);
var query = new ViewQuery("bucket-name", "http://localhost");
query.Keys("test-key");
await queryClient.ExecuteAsync <dynamic, dynamic>(query).ConfigureAwait(false);
Assert.NotNull(queryClient.LastActivity);
}
public void Can_export_deferred_handle()
{
const string handleUri = "/analytics/service/status/3-0";
const string expectedJson = "{\"v\":1,\"uri\":\"/analytics/service/status/3-0\"}";
var handle = new AnalyticsDeferredResultHandle <dynamic>(null, null, null, handleUri);
var options = new ClusterOptions();
options.WithServers("http://localhost");
var context = new ClusterContext(null, options);
var httpClient = new HttpClient(
FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK))
);
var client = new AnalyticsClient(httpClient,
new JsonDataMapper(new DefaultSerializer()),
context);
var encodedHandle = client.ExportDeferredQueryHandle(handle);
Assert.Equal(expectedJson, encodedHandle);
}
public void ViewClient_Submits_ViewQuery_Using_Post()
{
var keys = Enumerable.Range(1, 10).Select(i => $"key-{i}").ToList();
var expectedJson = JsonConvert.SerializeObject(new
{
keys
}, Formatting.None);
var handler = FakeHttpMessageHandler.Create(request =>
{
// verify request was a post
Assert.AreEqual(HttpMethod.Post, request.Method);
// get the post body and verify content
var content = request.Content.ReadAsStringAsync().Result;
Assert.AreEqual(expectedJson, content);
// return empty json response
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{ }")
});
});
var httpClient = new HttpClient(handler);
var queryClient = new ViewClient(httpClient,
new JsonDataMapper(new DefaultSerializer()),
ContextFactory.GetCouchbaseContext());
var query = new ViewQuery("bucket-name", "http://localhost");
query.Keys(keys);
var result = queryClient.Execute <dynamic>(query);
Assert.IsTrue(result.Success);
}
public void Execute_Sets_LastActivity()
{
var handler = FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{ }")
});
var httpClient = new HttpClient(handler);
var queryClient = new StreamingViewClient(httpClient,
new JsonDataMapper(new DefaultSerializer()),
ContextFactory.GetCouchbaseContext());
Assert.IsNull(queryClient.LastActivity);
var query = new ViewQuery("bucket-name", "http://localhost");
query.Keys("test-key");
query.UseStreaming(true);
var result = queryClient.Execute <dynamic>(query);
Assert.IsTrue(result.Success);
Assert.IsNotNull(queryClient.LastActivity);
}
public void GetDesignDocument_ThrowsException_ReturnsFailure()
{
// Arrange
var handler = FakeHttpMessageHandler.Create(request =>
{
throw new AggregateException();
});
var managerMock = new Mock <BucketManager>(_mockBucket, _clientConfiguration, new HttpClient(),
new Views.JsonDataMapper(_clientConfiguration), "username", "password");
managerMock.Setup(x => x.CreateAuthenticatedHttpClient()).Returns(new HttpClient(handler));
// Act
var result = managerMock.Object.GetDesignDocument("test");
// Assert
Assert.IsFalse(result.Success);
Assert.IsNotNull(result.Exception);
Assert.IsAssignableFrom <AggregateException>(result.Exception);
}
public void GetDesignDocument_WhenSuccessful_ReturnsSuccess()
{
// Arrange
var handler = FakeHttpMessageHandler.Create(request =>
new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("response")
});
var managerMock = new Mock <BucketManager>(_mockBucket, _clientConfiguration,
new Views.JsonDataMapper(_clientConfiguration), new HttpClient(handler), "username", "password");
managerMock.Setup(x => x.GetDesignDocument(It.IsAny <string>())).CallBase();
managerMock.Setup(x => x.GetDesignDocumentAsync(It.IsAny <string>())).CallBase();
// Act
var result = managerMock.Object.GetDesignDocument("test");
// Assert
Assert.IsTrue(result.Success);
}
public async Task QueryAsync_Sets_LastActivity()
{
var configuration = new ClusterOptions().WithServers("http://localhost");
configuration.GlobalNodes.Add(new ClusterNode {
AnalyticsUri = new Uri("http://localhost:8094/query")
});
var httpClient = new HttpClient(
FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{}")
})
);
var client = new AnalyticsClient(httpClient, new JsonDataMapper(new DefaultSerializer()), configuration);
Assert.Null(client.LastActivity);
var queryRequest = new AnalyticsRequest("SELECT * FROM `default`;");
await client.QueryAsync <dynamic>(queryRequest, CancellationToken.None).ConfigureAwait(false);
Assert.NotNull(client.LastActivity);
}
public void Flush_ThrowsException_ReturnsFailure()
{
// Arrange
var handler = FakeHttpMessageHandler.Create(request =>
{
throw new AggregateException();
});
var managerMock = new Mock <BucketManager>(_mockBucket, _clientConfiguration,
new JsonDataMapper(_clientConfiguration), new HttpClient(handler), "username", "password");
managerMock.Setup(x => x.FlushAsync()).CallBase();
// Act
var result = managerMock.Object.Flush();
// Assert
Assert.IsFalse(result.Success);
Assert.IsNotNull(result.Exception);
Assert.IsAssignableFrom <AggregateException>(result.Exception);
}
public async Task ViewClient_Submits_ViewQuery_Using_Post()
{
var keys = Enumerable.Range(1, 10).Select(i => $"key-{i}").ToList();
var expectedJson = JsonConvert.SerializeObject(new
{
keys
}, Formatting.None);
var handler = FakeHttpMessageHandler.Create(request =>
{
// verify request was a post
Assert.Equal(HttpMethod.Post, request.Method);
// get the post body and verify content
var content = request.Content.ReadAsStringAsync().Result;
Assert.Equal(expectedJson, content);
// return empty json response
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{ }")
});
});
var httpClient = new HttpClient(handler);
var httpClientFactory = new MockHttpClientFactory(httpClient);
var serializer = new DefaultSerializer();
var queryClient = new ViewClient(httpClientFactory, serializer, new Mock <ILogger <ViewClient> >().Object,
new Mock <IRedactor>().Object, NoopRequestTracer.Instance);
var query = new ViewQuery("bucket-name", "http://localhost");
query.Keys(keys);
await queryClient.ExecuteAsync <dynamic, dynamic>(query).ConfigureAwait(false);
}
public async Task QueryAsync_Sets_LastActivity()
{
var httpClient = new CouchbaseHttpClient(
FakeHttpMessageHandler.Create(request => new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{}")
})
);
var mockServiceUriProvider = new Mock <IServiceUriProvider>();
mockServiceUriProvider
.Setup(m => m.GetRandomAnalyticsUri())
.Returns(new Uri("http://localhost:8096"));
var serializer = new DefaultSerializer();
var client = new AnalyticsClient(httpClient, mockServiceUriProvider.Object, serializer,
new Mock <ILogger <AnalyticsClient> >().Object, NoopRequestTracer.Instance);
Assert.Null(client.LastActivity);
await client.QueryAsync <dynamic>("SELECT * FROM `default`;", new AnalyticsOptions()).ConfigureAwait(false);
Assert.NotNull(client.LastActivity);
}
public async Task SearchQueriesUseCorrectPath()
{
const string indexName = "test-index";
using var handler = FakeHttpMessageHandler.Create((req) =>
{
Assert.Equal("http://localhost:8094/api/index/test-index/query", req.RequestUri.ToString());
return(new HttpResponseMessage
{
Content = new StreamContent(new MemoryStream())
});
});
var httpClient = new CouchbaseHttpClient(handler);
var mockServiceUriProvider = new Mock <IServiceUriProvider>();
mockServiceUriProvider
.Setup(m => m.GetRandomSearchUri())
.Returns(new Uri("http://localhost:8094"));
var client = new SearchClient(httpClient, mockServiceUriProvider.Object, new SearchDataMapper());
await client.QueryAsync(new SearchRequest { Index = indexName, Options = new SearchOptions() });
}
public void GetUsers_Returns_Users_When_Response_Is_Success(HttpStatusCode responseHttpCode)
{
var expectedUsers = new List <User>
{
new User
{
Username = "******",
Name = "Alice Liddell",
Domain = "builtin",
Roles = new List <Role> {
new Role {
Name = "Admin"
}
}
},
new User
{
Username = "******",
Name = "White Rabbit",
Domain = "builtin",
Roles = new List <Role> {
new Role {
Name = "BucketManager", BucketName = "default"
}
}
},
new User
{
Username = "******",
Name = "Mad Hatter",
Domain = "builtin",
Roles = new List <Role> {
new Role {
Name = "FTSAdmin"
}
}
}
};
var handler = FakeHttpMessageHandler.Create(
request => new HttpResponseMessage(responseHttpCode)
{
Content = new StringContent(JsonConvert.SerializeObject(expectedUsers))
}
);
var client = new HttpClient(handler);
var clientConfig = new ClientConfiguration();
var serverConfigMock = new Mock <IServerConfig>();
var dataMapper = new JsonDataMapper(clientConfig);
var manager = new ClusterManager(clientConfig, serverConfigMock.Object, dataMapper, client, "username", "password");
var result = manager.GetUsers(AuthenticationDomain.Local);
if (responseHttpCode == HttpStatusCode.OK)
{
Assert.IsTrue(result.Success);
Assert.AreEqual(expectedUsers.Count, result.Value.Count());
}
else
{
Assert.IsFalse(result.Success);
Assert.IsNull(result.Value);
}
}
