public void Dispose_DisposesCluster()
{
// Arrange
var clientDefinition = new CouchbaseClientDefinition();
var options = new Mock <IOptions <CouchbaseClientDefinition> >();
options.SetupGet(m => m.Value).Returns(clientDefinition);
var loggerFactory = new LoggerFactory();
var cluster = new Mock <ICluster>();
cluster.Setup(m => m.Dispose());
var provider = new Mock <ClusterProvider>(options.Object, loggerFactory)
{
CallBase = true
};
provider.Protected()
.Setup <ICluster>("CreateCluster", clientDefinition)
.Returns(cluster.Object);
provider.Object.GetCluster();
// Act
provider.Object.Dispose();
// Assert
cluster.Verify(m => m.Dispose(), Times.AtLeastOnce);
}
public void GetCluster_TwoCalls_OnlyCreatesOneCluster()
{
// Arrange
var clientDefinition = new CouchbaseClientDefinition();
var options = new Mock <IOptions <CouchbaseClientDefinition> >();
options.SetupGet(m => m.Value).Returns(clientDefinition);
var loggerFactory = new LoggerFactory();
var cluster = new Mock <ICluster>();
var provider = new Mock <ClusterProvider>(options.Object, loggerFactory)
{
CallBase = true
};
provider.Protected()
.Setup <ICluster>("CreateCluster", clientDefinition)
.Returns(cluster.Object);
// Act
provider.Object.GetCluster();
var result = provider.Object.GetCluster();
// Assert
Assert.Equal(cluster.Object, result);
provider.Protected()
.Verify <ICluster>("CreateCluster", Times.Once(), clientDefinition);
}
public void Apply(CouchbaseClientDefinition clientDefinition)
{
if (clientDefinition == null)
{
throw new ArgumentNullException(nameof(clientDefinition));
}
if (clientDefinition.Servers.Count != 1)
{
// Must have a single host
return;
}
var recordName = TestForSrvRecordName(clientDefinition.Servers[0]);
if (recordName != null)
{
var resolvedServers = Resolve(recordName);
if (resolvedServers != null)
{
clientDefinition.Servers.Clear();
clientDefinition.Servers.AddRange(resolvedServers);
}
}
// Leaves servers in place if no DNS SRV records match
}
public void ConnectionString_ReplacesServers(string connectionString, Uri[] expected)
{
// Arrange
var definition = new CouchbaseClientDefinition
{
ConnectionString = connectionString,
Servers = new List <Uri>
{
new Uri("http://old1"),
new Uri("http://old2")
}
};
// Act
var configuration = new ClientConfiguration(definition);
// Assert
Assert.AreEqual(expected.Length, configuration.Servers.Count);
for (var i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], configuration.Servers[i]);
}
}
public string Get()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("config.json");
var jsonConfiguration = builder.Build();
var definition = new CouchbaseClientDefinition();
jsonConfiguration.GetSection("couchbase:basic").Bind(definition);
var clientConfig = new ClientConfiguration(definition);
using (var cluster = new Cluster(clientConfig))
{
using (var bucket = cluster.OpenBucket("travel-sample"))
{
// Query to get 10 documents.
using (var queryResult = bucket.Query <dynamic>("SELECT * FROM `travel-sample` LIMIT 10"))
{
return(JsonConvert.SerializeObject(queryResult));
//return "HELLO WORLD v2";
}
}
}
}
public void Apply_UnhandledException_LogsError()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(RecordName))
.ThrowsAsync(new Exception("Badness Happened"));
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
logger.Setup(
m =>
m.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <object>(), It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >()));
var clientDefinition = new CouchbaseClientDefinition();
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition, RecordName);
// Assert
logger.Verify(
m =>
m.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <object>(), It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >()),
Times.AtLeastOnce);
}
public void ApplyNoRecordName_CouchbaseWithPort_NoDnsLookup()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(It.IsAny <string>()))
.ReturnsAsync(new List <SrvRecord>());
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
Servers = new List <Uri>
{
new Uri("couchbase://server:1000/")
}
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition);
// Assert
Assert.Equal(1, clientDefinition.Servers.Count);
Assert.Equal(new Uri("couchbase://server:1000/"), clientDefinition.Servers[0]);
lookupClient
.Verify(m => m.QuerySrvAsync(It.IsAny <string>()), Times.Never);
}
public void Apply_HasServerList_ClearsListFirst()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(RecordName))
.Returns(Task.FromResult(new []
{
SrvRecord1Priority10,
SrvRecord2Priority10
}.AsEnumerable()));
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
Servers = new List <Uri>
{
new Uri("http://shouldremove/")
}
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition, RecordName);
// Assert
Assert.Equal(2, clientDefinition.Servers.Count);
}
private void ApplyFromConnectionString(CouchbaseClientDefinition clientDefinition)
{
Uri uri;
try
{
uri = new Uri(clientDefinition.ConnectionString);
}
catch (UriFormatException)
{
// We should only perform DNS SRV lookups on a connection string with a single server listed
// Any URI with more than one server (comma delimited) will fail to parse as a URI
// So just short circuit on UriFormatException
return;
}
var recordName = TestForSrvRecordName(uri);
if (recordName != null)
{
var resolvedServers = Resolve(recordName, true);
if (resolvedServers != null)
{
clientDefinition.ConnectionString = ReplaceConnectionStringServers(uri, resolvedServers);
}
}
// Leaves servers in place if no DNS SRV records match
}
public void ApplyNoRecordNameWithConnectionString_CouchbaseNoDnsSrvFound_Unmodified()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(FullRecordName))
.ReturnsAsync(new List <SrvRecord>());
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
ConnectionString = "couchbase://services.local/"
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition);
// Assert
Assert.Equal("couchbase://services.local/", clientDefinition.ConnectionString);
Assert.Null(clientDefinition.Servers);
lookupClient
.Verify(m => m.QuerySrvAsync(FullRecordName), Times.Once);
}
public static IServiceCollection AddCouchbase(this IServiceCollection services)
{
var clientDefinition = new CouchbaseClientDefinition
{
Username = CouchbaseOptions.Username,
Password = CouchbaseOptions.Password,
Servers = new List <Uri>
{
new Uri(CouchbaseOptions.Host)
},
};
var authenticator = new PasswordAuthenticator(CouchbaseOptions.Username, CouchbaseOptions.Password);
var configuration = new ClientConfiguration(clientDefinition);
configuration.SetAuthenticator(authenticator);
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var serializer = new DefaultSerializer(serializerSettings, serializerSettings);
configuration.Serializer = () => serializer;
var cluster = new Cluster(configuration);
services.AddTransient <ICluster>(sp => cluster);
services.AddTransient(sp => cluster.OpenBucket("payroll"));
services.AddSingleton <ITypeSerializer>(new DefaultSerializer(serializerSettings, serializerSettings));
return(services);
}
public void ApplyNoRecordNameWithConnectionString_CouchbaseDnsSrvFound_IgnoresPriority()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(FullRecordName))
.ReturnsAsync(new List <SrvRecord>
{
SrvRecord1Priority10,
SrvRecord2Priority10,
SrvRecord3Priority20,
SrvRecord4Priority20
});
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
ConnectionString = "couchbase://services.local"
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition);
// Assert
Assert.Equal("couchbase://couchbaseserver1.services.local:8091,couchbaseserver2.services.local:8091,couchbaseserver3.services.local:8091,couchbaseserver4.services.local:8091/",
clientDefinition.ConnectionString);
Assert.Null(clientDefinition.Servers);
}
public void ApplyNoRecordNameWithConnectionString_CouchbaseDnsSrvFound_Replaces(string scheme)
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync($"_{scheme}._tcp.services.local"))
.ReturnsAsync(new List <SrvRecord>
{
SrvRecord1Priority10,
SrvRecord2Priority10
});
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
ConnectionString = $"{scheme}://services.local/additionalPath?queryParam=5"
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition);
// Assert
Assert.Equal($"{scheme}://couchbaseserver1.services.local:8091,couchbaseserver2.services.local:8091/additionalPath?queryParam=5",
clientDefinition.ConnectionString);
Assert.Null(clientDefinition.Servers);
}
public static CouchbaseClientDefinition GetCouchbaseClientDefinition(IConfigurationRoot Configuration)
{
var couchbaseClientDefinition = new CouchbaseClientDefinition();
Configuration.GetSection(CouchBaseClientKeyName).Bind(couchbaseClientDefinition);
return(couchbaseClientDefinition);
}
private static ICluster GetCluster()
{
var clientDefinition = new CouchbaseClientDefinition
{
Buckets = new List <BucketDefinition>
{
new BucketDefinition
{
Name = "protoactor-test",
ConnectionPool = new ConnectionPoolDefinition
{
EnableTcpKeepAlives = true,
MaxSize = 100,
MinSize = 10
}
}
},
Servers = new List <Uri>
{
new Uri("http://localhost:8091")
}
};
var jsonSerializerSettings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var configuration = new ClientConfiguration(clientDefinition)
{
Serializer = () => new DefaultSerializer(jsonSerializerSettings, jsonSerializerSettings)
};
return(new Cluster(configuration));
}
public void When_UseConnectionPooling_Is_True_IOServiceFactory_Returns_PooledIOService()
{
var definition = new CouchbaseClientDefinition
{
UseConnectionPooling = true
};
var clientConfig = new ClientConfiguration(definition);
clientConfig.Initialize();
var mockConnection = new Mock <IConnection>();
mockConnection.Setup(x => x.IsAuthenticated).Returns(true);
var mockConnectionPool = new Mock <IConnectionPool>();
mockConnectionPool.Setup(x => x.Acquire()).Returns(mockConnection.Object);
mockConnectionPool.Setup(x => x.Configuration).Returns(new PoolConfiguration());
mockConnectionPool.Setup(x => x.Connections).Returns(new List <IConnection> {
mockConnection.Object
});
var service = clientConfig.IOServiceCreator.Invoke(mockConnectionPool.Object);
Assert.IsInstanceOf <PooledIOService>(service);
}
public async Task Test_Http()
{
var definition = new CouchbaseClientDefinition
{
ConnectionString = "http://" + TestConfiguration.Settings.Hostname
};
using (var cluster = new Cluster(definition))
{
cluster.SetupEnhancedAuth();
using (var bucket = cluster.OpenBucket())
{
const string key = "thekey";
const string value = "thevalue";
await bucket.RemoveAsync(key);
await bucket.InsertAsync(key, value);
var result = await bucket.GetAsync <string>(key);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
}
}
public void ApplyNoRecordNameWithConnectionString_MultipleEntriesWithSemicolon_NoDnsLookup()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(It.IsAny <string>()))
.ReturnsAsync(new List <SrvRecord>());
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition
{
ConnectionString = "couchbase://server;server2/"
};
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition);
// Assert
Assert.Equal("couchbase://server;server2/", clientDefinition.ConnectionString);
Assert.Null(clientDefinition.Servers);
lookupClient
.Verify(m => m.QuerySrvAsync(It.IsAny <string>()), Times.Never);
}
public void Apply_ShortRecordName_ReturnsServersFromFullRecordNameIfPresent()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
lookupClient
.Setup(m => m.QuerySrvAsync(RecordName))
.Returns(Task.FromResult(new[]
{
SrvRecord2Priority10
}.AsEnumerable()));
lookupClient
.Setup(m => m.QuerySrvAsync(FullRecordName))
.Returns(Task.FromResult(new[]
{
SrvRecord1Priority10
}.AsEnumerable()));
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition();
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act
lookup.Apply(clientDefinition, RecordName);
// Assert
Assert.Equal(1, clientDefinition.Servers.Count);
Assert.Equal(ServerRecord1ExpectedUrl, clientDefinition.Servers[0]);
}
/// <summary>
/// Seam for injecting mock
/// </summary>
protected virtual ICluster CreateCluster(CouchbaseClientDefinition clientDefinition)
{
var configuration = new ClientConfiguration(clientDefinition)
{
LoggerFactory = _loggerFactory
};
return(new Cluster(configuration));
}
private static ClientConfiguration DefaultLocalhostConfig()
{
EnsureConfigurationLoaded();
var definition = new CouchbaseClientDefinition();
_jsonConfiguration.GetSection("couchbase").Bind(definition);
return(new ClientConfiguration(definition));
}
public void CouchbaseClientDefinition_CorrectDefault()
{
var definition = new CouchbaseClientDefinition();
var config = new ClientConfiguration(definition);
config.Initialize();
Assert.AreEqual(ServerConfigurationProviders.CarrierPublication | ServerConfigurationProviders.HttpStreaming,
config.ConfigurationProviders);
}
static MemcachedCacheProviderHelper()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("appsettings.json");
var jsonConfiguration = builder.Build();
var definition = new CouchbaseClientDefinition();
jsonConfiguration.GetSection("Couchbase").Bind(definition);
ClientConfiguration = new ClientConfiguration(definition);
}
public void CouchbaseClientDefinition_ConfigurationProviders_Passthrough(ServerConfigurationProviders configurationProviders)
{
var definition = new CouchbaseClientDefinition
{
ConfigurationProviders = configurationProviders
};
var config = new ClientConfiguration(definition);
config.Initialize();
Assert.AreEqual(configurationProviders, config.ConfigurationProviders);
}
public static ICouchbaseClientDefinition GetConfiguration()
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile("configuration.json");
var configurationSection = builder.Build().GetSection("Couchbase");
var definition = new CouchbaseClientDefinition();
configurationSection.Bind(definition);
return(definition);
}
public void Apply(CouchbaseClientDefinition clientDefinition)
{
if (clientDefinition == null)
{
throw new ArgumentNullException(nameof(clientDefinition));
}
if (!string.IsNullOrEmpty(clientDefinition.ConnectionString))
{
ApplyFromConnectionString(clientDefinition);
}
else
{
ApplyFromServers(clientDefinition);
}
}
/// <summary>
/// Seam for injecting mock
/// </summary>
protected virtual ICluster CreateCluster(CouchbaseClientDefinition clientDefinition)
{
var configuration = new ClientConfiguration(clientDefinition)
{
LoggerFactory = _loggerFactory
};
ICluster cluster = new Cluster(configuration);
if (!string.IsNullOrWhiteSpace(clientDefinition.Username))
{
cluster.Authenticate(new PasswordAuthenticator(clientDefinition.Username, clientDefinition.Password));
}
return(cluster);
}
public void Apply_NoRecordName_Exception()
{
// Arrange
var lookupClient = new Mock <ILookupClientAdapter>();
var logger = new Mock <ILogger <CouchbaseDnsLookup> >();
var clientDefinition = new CouchbaseClientDefinition();
var lookup = new CouchbaseDnsLookup(lookupClient.Object, logger.Object);
// Act/Assert
var ex = Assert.Throws <ArgumentNullException>(() => lookup.Apply(clientDefinition, null));
Assert.Equal("recordName", ex.ParamName);
}
public static ClientConfiguration ReadConfiguration(IConfigurationRoot configuration, string sectionName = "couchbase:clientConfiguration")
{
try
{
var definition = new CouchbaseClientDefinition();
var section = configuration.GetSection(sectionName);
section.Bind(definition);
var clientConfig = new ClientConfiguration(definition);
return(clientConfig);
}
catch (Exception ex)
{
throw new InvalidCouchbaseConfigurationException($"The section '{sectionName}' of configuration is not in the expected format", ex);
}
}
public void ConfigurationProviders_ParsedCorrectly(string value, ServerConfigurationProviders expected)
{
var builder = new ConfigurationBuilder();
builder.AddInMemoryCollection(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Couchbase:ConfigurationProviders", value)
});
var config = builder.Build();
var definition = new CouchbaseClientDefinition();
config.GetSection("Couchbase").Bind(definition);
Assert.AreEqual(expected, definition.ConfigurationProviders);
}
