/// <summary>
/// Initializes a new instance of the <see cref="ConnectionFactoryBase"/> class.
/// </summary>
/// <param name="connectionString">The connection string.</param>
protected ConnectionFactoryBase(string connectionString){
if(connectionString == null)
throw new ArgumentNullException("connectionString");
ConnectionString = connectionString;
Builder = new MongoConnectionStringBuilder(connectionString);
}
/// <summary>
/// Saves the events.
/// </summary>
/// <param name="aggregateID">The aggregate ID.</param>
/// <param name="events">The events.</param>
public void SaveEvents(object aggregateID, IEnumerable <Event> events)
{
var connectionStringBuilder = new MongoConnectionStringBuilder(_connectionString);
var database = MongoServer.Create(connectionStringBuilder).GetDatabase(connectionStringBuilder.DatabaseName);
database.GetCollection <Event>(_tableName).Insert(events);
}
public void TestToStringOutputWithDefaultServerPort()
{
var builder = new MongoConnectionStringBuilder();
builder.AddServer("testserver");
Assert.AreEqual("Server=testserver", builder.ToString());
}
public void TestDefaults()
{
string connectionString = "server=localhost";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.IsNull(builder.Username);
Assert.IsNull(builder.Password);
Assert.AreEqual(1, builder.Servers.Count());
Assert.AreEqual("localhost", builder.Servers.Single().Host);
Assert.AreEqual(27017, builder.Servers.Single().Port);
Assert.IsNull(builder.DatabaseName);
Assert.AreEqual(ConnectionMode.Direct, builder.ConnectionMode);
Assert.AreEqual(MongoDefaults.ConnectTimeout, builder.ConnectTimeout);
Assert.AreEqual(MongoDefaults.GuidRepresentation, builder.GuidRepresentation);
Assert.AreEqual(false, builder.IPv6);
Assert.AreEqual(MongoDefaults.MaxConnectionIdleTime, builder.MaxConnectionIdleTime);
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, builder.MaxConnectionLifeTime);
Assert.AreEqual(MongoDefaults.MaxConnectionPoolSize, builder.MaxConnectionPoolSize);
Assert.AreEqual(null, builder.ReplicaSetName);
Assert.IsNull(builder.SafeMode);
Assert.AreEqual(false, builder.SlaveOk);
Assert.AreEqual(MongoDefaults.SocketTimeout, builder.SocketTimeout);
Assert.AreEqual(MongoDefaults.WaitQueueMultiple, builder.WaitQueueMultiple);
Assert.AreEqual(MongoDefaults.WaitQueueSize, builder.WaitQueueSize);
Assert.AreEqual(MongoDefaults.WaitQueueTimeout, builder.WaitQueueTimeout);
Assert.AreEqual(connectionString, builder.ToString());
}
public DefaultMongoRepositoryFactory(ConnectionInfo connectionInfo)
{
var urlBuilder = new MongoConnectionStringBuilder(connectionInfo.ConnectionString);
var mongoClient = new MongoClient(connectionInfo.ConnectionString);
this.mongoDatabase = mongoClient.GetServer().GetDatabase(urlBuilder.DatabaseName);
}
public void TestMaximumPoolSizeIsEnsured()
{
var builder = new MongoConnectionStringBuilder { MaximumPoolSize = 2 };
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection1 = pool.Open();
Assert.IsNotNull(connection1);
Assert.IsNotNull(pool.Open());
RawConnection connection3 = null;
var thread = new Thread(o =>
{
connection3 = pool.Open();
});
thread.Start();
Thread.Sleep(300);
Assert.IsNull(connection3);
pool.Close(connection1);
Thread.Sleep(300);
Assert.IsNotNull(connection3);
thread.Abort();
}
}
private void btConnect_Click(object sender, EventArgs e)
{
if (!ServerConnection.Connected)
{
try
{
var connectionString = new MongoConnectionStringBuilder();
connectionString.Server = new MongoServerAddress(tbServerAddress.Text);
connectionString.Username = tbUser.Text;
connectionString.Password = tbPassword.Text;
connectionString.DatabaseName = "test";
//new ServerConnection(tbServerAddress.Text);
new ServerConnection(connectionString);
//FillComboboxWithDatabaseNames(ServerConnection.Server);
SetConnectedState();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
tbServerAddress.Focus();
}
}
else
{
//ServerConnection.DatabaseName = cbDatabases.Text;
ServerConnection.DatabaseName = "test";
CloseLoginFormOpenMain();
}
}
public MongoEventStore(string connectionString, ITypeCatalog typeCatalog)
{
var connectionStringBuilder = new MongoConnectionStringBuilder(connectionString);
databaseName = connectionStringBuilder.Database;
configuration = BuildMongoConfiguration(typeCatalog, connectionString);
}
public void TestUriWithPropertys()
{
var builder = new MongoConnectionStringBuilder("mongodb://server1/database?pooled=false&connectionlifetime=10");
Assert.AreEqual(false, builder.Pooled);
Assert.AreEqual(10.0, builder.ConnectionLifetime.TotalSeconds);
}
public void TestFromMongoConnectionStringBuilder()
{
// set everything to non default values to test that all settings are converted
var connectionString =
"server=somehost;username=user1;password=password1;" +
"connect=direct;connectTimeout=123;uuidRepresentation=pythonLegacy;ipv6=true;" +
"maxIdleTime=124;maxLifeTime=125;maxPoolSize=126;minPoolSize=127;" +
"readPreference=secondary;readPreferenceTags=a:1,b:2|c:3,d:4;secondaryAcceptableLatency=128;socketTimeout=129;" +
"ssl=true;sslVerifyCertificate=false;waitqueuesize=130;waitQueueTimeout=131;" +
"w=1;fsync=true;journal=true;w=2;wtimeout=131";
var builder = new MongoConnectionStringBuilder(connectionString);
var settings = MongoClientSettings.FromConnectionStringBuilder(builder);
Assert.AreEqual(builder.ConnectionMode, settings.ConnectionMode);
Assert.AreEqual(builder.ConnectTimeout, settings.ConnectTimeout);
Assert.AreEqual("{}", settings.CredentialsStore.ToString());
Assert.AreEqual(new MongoCredentials("user1", "password1"), settings.DefaultCredentials);
Assert.AreEqual(builder.GuidRepresentation, settings.GuidRepresentation);
Assert.AreEqual(builder.IPv6, settings.IPv6);
Assert.AreEqual(builder.MaxConnectionIdleTime, settings.MaxConnectionIdleTime);
Assert.AreEqual(builder.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
Assert.AreEqual(builder.MaxConnectionPoolSize, settings.MaxConnectionPoolSize);
Assert.AreEqual(builder.MinConnectionPoolSize, settings.MinConnectionPoolSize);
Assert.AreEqual(builder.ReadPreference, settings.ReadPreference);
Assert.AreEqual(builder.ReplicaSetName, settings.ReplicaSetName);
Assert.AreEqual(builder.SecondaryAcceptableLatency, settings.SecondaryAcceptableLatency);
Assert.IsTrue(builder.Servers.SequenceEqual(settings.Servers));
Assert.AreEqual(builder.SocketTimeout, settings.SocketTimeout);
Assert.AreEqual(builder.UseSsl, settings.UseSsl);
Assert.AreEqual(builder.VerifySslCertificate, settings.VerifySslCertificate);
Assert.AreEqual(builder.ComputedWaitQueueSize, settings.WaitQueueSize);
Assert.AreEqual(builder.WaitQueueTimeout, settings.WaitQueueTimeout);
Assert.AreEqual(builder.GetWriteConcern(true), settings.WriteConcern);
}
/// <summary>
/// MongoDB 서버에 접속하기 위한 <see cref="MongoConnectionStringBuilder"/>를 빌드 합니다.
/// </summary>
/// <param name="serverName">Mongo Server IP 또는 DNS 명</param>
/// <param name="port">Port</param>
/// <param name="databaseName">MongoDB의 database 명</param>
/// <param name="username">사용자명</param>
/// <param name="password">비밀번호</param>
/// <returns><see cref="MongoConnectionStringBuilder"/> 인스턴스</returns>
public static MongoConnectionStringBuilder GetMongoConnectionBuilder(string serverName, int?port, string databaseName,
string username, string password)
{
serverName.ShouldNotBeWhiteSpace("serverName");
var builder = new MongoConnectionStringBuilder
{
Server = port.HasValue
? new MongoServerAddress(serverName, port.Value)
: new MongoServerAddress(serverName),
SafeMode = SafeMode.True,
DatabaseName = databaseName ?? DefaultDatabaseName
};
if (username.IsNotWhiteSpace())
{
builder.Username = username;
}
if (password.IsNotWhiteSpace())
{
builder.Password = password;
}
return(builder);
}
public MongoHelper(string ConnectionString)
{
var con = new MongoConnectionStringBuilder(ConnectionString);
var server = MongoServer.Create(con);
this.Database = server.GetDatabase(con.DatabaseName);
}
public void TestTwoIPv6AddressesWithDefaultCredentials()
{
var connectionString = "mongodb://*****:*****@[::1:],[::2:]/?safe=true";
var url = new MongoUrl(connectionString);
var servers = url.Servers.ToArray();
Assert.AreEqual(2, servers.Length);
Assert.AreEqual("[::1:]", servers[0].Host);
Assert.AreEqual(27017, servers[0].Port);
Assert.AreEqual("[::2:]", servers[1].Host);
Assert.AreEqual(27017, servers[1].Port);
Assert.AreEqual("username", url.DefaultCredentials.Username);
Assert.AreEqual("password", url.DefaultCredentials.Password);
Assert.AreEqual(true, url.SafeMode.Enabled);
connectionString = "servers=[::1:],[::2:];username=username;password=password;safe=true";
var builder = new MongoConnectionStringBuilder(connectionString);
servers = builder.Servers.ToArray();
Assert.AreEqual(2, servers.Length);
Assert.AreEqual("[::1:]", servers[0].Host);
Assert.AreEqual(27017, servers[0].Port);
Assert.AreEqual("[::2:]", servers[1].Host);
Assert.AreEqual(27017, servers[1].Port);
Assert.AreEqual("username", url.DefaultCredentials.Username);
Assert.AreEqual("password", url.DefaultCredentials.Password);
Assert.AreEqual(true, builder.SafeMode.Enabled);
}
public void TestConnectTimeout()
{
string connectionString = "server=localhost;connectTimeout=123";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromSeconds(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString + "s", builder.ToString()); // "s" units added
connectionString = "server=localhost;connectTimeout=123ms";
builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromMilliseconds(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
connectionString = "server=localhost;connectTimeout=123s";
builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromSeconds(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
connectionString = "server=localhost;connectTimeout=123m";
builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromMinutes(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
connectionString = "server=localhost;connectTimeout=123h";
builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromHours(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
}
public MongoHelper()
{
var con = new MongoConnectionStringBuilder(ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString);
var server = MongoServer.Create(con);
this.Database = server.GetDatabase(con.DatabaseName);
}
public void TestSimpleUriStringWithDatabase(){
var builder = new MongoConnectionStringBuilder("mongodb://server/database");
Assert.AreEqual("database", builder.Database);
Assert.AreEqual(1, builder.Servers.Length);
Assert.AreEqual("server", builder.Servers[0].Host);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, builder.Servers[0].Port);
}
public DefaultMongoDbProvider()
{
var connectionStringBuilder =
new MongoConnectionStringBuilder(ConfigurationManager.AppSettings["MongoConnectionString"]);
var server = MongoServer.Create(connectionStringBuilder);
_database = server.GetDatabase(connectionStringBuilder.DatabaseName);
}
public void TestMaximumPoolSizeIsEnsured()
{
var builder = new MongoConnectionStringBuilder {
MaximumPoolSize = 2
};
using (var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection1 = pool.Open();
Assert.IsNotNull(connection1);
Assert.IsNotNull(pool.Open());
RawConnection connection3 = null;
var thread = new Thread(o =>
{
connection3 = pool.Open();
});
thread.Start();
Thread.Sleep(300);
Assert.IsNull(connection3);
pool.Close(connection1);
Thread.Sleep(300);
Assert.IsNotNull(connection3);
thread.Abort();
}
}
private MongoDatabase GetDatabaseFromConnectionString(string connectionString)
{
var conString = new MongoConnectionStringBuilder(connectionString);
MongoClientSettings settings = MongoClientSettings.FromConnectionStringBuilder(conString);
MongoServer server = new MongoClient(settings).GetServer();
return(server.GetDatabase(conString.DatabaseName));
}
public void TestMaxConnectionLifeTime()
{
string connectionString = "server=localhost;maxLifeTime=123ms";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromMilliseconds(123), builder.MaxConnectionLifeTime);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestSlaveOkTrue()
{
string connectionString = "server=localhost;slaveOk=true";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(true, builder.SlaveOk);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestSafeModeJFalse()
{
string connectionString = "server=localhost;safe=true;j=false";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(false, builder.SafeMode.J);
Assert.AreEqual("server=localhost;safe=true", builder.ToString()); // j=false dropped
}
public void TestSafeModeJTrue()
{
string connectionString = "server=localhost;safe=true;j=true";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(true, builder.SafeMode.J);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestSafeModeW2()
{
string connectionString = "server=localhost;w=2";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(SafeMode.W2, builder.SafeMode);
Assert.AreEqual("server=localhost;safe=true;w=2", builder.ToString()); // safe=true added
}
public void TestSafeModeTrueFSyncTrueW2()
{
string connectionString = "server=localhost;safe=true;fsync=true;w=2";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(SafeMode.Create(true, true, 2), builder.SafeMode);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestSafeModeTrueFSyncTrueW2WTimeout()
{
string connectionString = "server=localhost;safe=true;fsync=true;w=2;wtimeout=2s";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(SafeMode.Create(true, true, 2, TimeSpan.FromSeconds(2)), builder.SafeMode);
Assert.AreEqual(connectionString, builder.ToString());
}
/// <summary>
/// Creates the factory.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <returns></returns>
private static IConnectionFactory CreateFactory(string connectionString){
var builder = new MongoConnectionStringBuilder(connectionString);
if(builder.Pooled)
return new PooledConnectionFactory(connectionString);
return new SimpleConnectionFactory(connectionString);
}
public void TestWaitQueueTimeout()
{
string connectionString = "server=localhost;waitQueueTimeout=123ms";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(TimeSpan.FromMilliseconds(123), builder.WaitQueueTimeout);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestMinConnectionPoolSize()
{
string connectionString = "server=localhost;minPoolSize=123";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(123, builder.MinConnectionPoolSize);
Assert.AreEqual(connectionString, builder.ToString());
}
private void AddNewConnection()
{
var sb = new MongoConnectionStringBuilder();
sb.Server = new MongoServerAddress(NewCSServer);
Connections.Add(NewCSName, sb.ConnectionString);
}
public void TestSafeModeFalse()
{
string connectionString = "server=localhost;safe=false";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(SafeMode.False, builder.SafeMode);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestToStringOutputWithoutUsernameAndPassword()
{
var builder = new MongoConnectionStringBuilder();
builder.AddServer("testserver", 555);
Assert.AreEqual("Server=testserver:555", builder.ToString());
}
public void TestIpV6()
{
string connectionString = "server=localhost;ipv6=true";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(true, builder.IPv6);
Assert.AreEqual(connectionString, builder.ToString());
}
public static MongoDatabase GetMongoDatabase()
{
var connectionString = ConfigurationManager.ConnectionStrings["Mongo"].ConnectionString;
var connection = new MongoConnectionStringBuilder(connectionString);
var server = MongoServer.Create(connection);
return(server.GetDatabase(connection.DatabaseName));
}
public void TestGuidRepresentationJavaLegacy()
{
string connectionString = "server=localhost;guids=JavaLegacy";
var builder = new MongoConnectionStringBuilder(connectionString);
Assert.AreEqual(GuidRepresentation.JavaLegacy, builder.GuidRepresentation);
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestCanCreateFromConnectionString()
{
var builder = new MongoConnectionStringBuilder(ConnectionString) {Database = "tests"};
/*
using(var database = new MongoDatabase(builder.ToString()))
{
}*/
}
public void TestExceptionIfMaximumPoolSizeAndConnectionTimeoutAreReached()
{
var builder = new MongoConnectionStringBuilder { MaximumPoolSize = 1, ConnectionTimeout = TimeSpan.FromMilliseconds(500)};
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
pool.Open();
pool.Open();
}
}
/// <summary>
/// Builds the connection string.
/// </summary>
/// <param name="config">The config.</param>
public void ConnectionString(Action<MongoConnectionStringBuilder> config)
{
if (config == null)
throw new ArgumentNullException("config");
var builder = new MongoConnectionStringBuilder();
config(builder);
_connectionString = builder.ToString();
}
public void TestConnectionStringParsingServerWithoutPort(){
var builder = new MongoConnectionStringBuilder("Username=testuser;Password=testpassword;Server=testserver");
Assert.AreEqual("testuser", builder.Username);
Assert.AreEqual("testpassword", builder.Password);
var servers = new List<MongoServerEndPoint>(builder.Servers);
Assert.AreEqual(1, servers.Count);
Assert.AreEqual("testserver", servers[0].Host);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, servers[0].Port);
}
public void TestBorrowOneConnection()
{
var builder = new MongoConnectionStringBuilder();
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection = pool.Open();
Assert.IsNotNull(connection);
Assert.AreEqual(1, pool.PoolSize);
}
}
// private static methods
private static MongoClientSettings ParseConnectionString(string connectionString)
{
if (connectionString.StartsWith("mongodb://"))
{
var url = new MongoUrl(connectionString);
return MongoClientSettings.FromUrl(url);
}
else
{
var builder = new MongoConnectionStringBuilder(connectionString);
return MongoClientSettings.FromConnectionStringBuilder(builder);
}
}
public void TestMinimalPoolSizeIsEnsuredAtRuntime()
{
var builder = new MongoConnectionStringBuilder { MinimumPoolSize = 3, ConnectionLifetime = TimeSpan.FromMilliseconds(200)};
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
Assert.AreEqual(3, pool.PoolSize);
Thread.Sleep(500); // ensure connection lifetime reached
pool.Cleanup();
Assert.AreEqual(3, pool.PoolSize);
}
}
public void Setup()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<EventDataLoader>().As<IEventDataLoader>();
containerBuilder.RegisterType<DefaultPreSaveEventListener>().As<IPreSaveOrUpdateEventListener>();
_container = containerBuilder.Build();
var connectionStringBuilder = new MongoConnectionStringBuilder(ConfigurationManager.ConnectionStrings["MongoDBConnectionString"].ConnectionString);
var mongoServer = MongoServer.Create(connectionStringBuilder);
_employerCollection = mongoServer.GetDatabase(connectionStringBuilder.DatabaseName).GetCollection<Employer>(typeof (Employer).Name);
DefaultSerializationProvider.InitializeProvider(typeof(IEntity), new DependencyResolver(_container));
}
public MongoEventStore(string connectionString)
{
var connectionStringBuilder = new MongoConnectionStringBuilder(connectionString);
_databaseName = connectionStringBuilder.DatabaseName;
_server = MongoServer.Create(connectionString);
_server.Connect();
_database = _server.GetDatabase(_databaseName);
Collection.EnsureIndex(
new IndexKeysBuilder()
.Ascending("AggregateRootId")
.Ascending("Sequence")
);
}
public void TestDefaults(){
var builder = new MongoConnectionStringBuilder();
Assert.IsNull(builder.Username);
Assert.IsNull(builder.Password);
Assert.AreEqual(builder.MaximumPoolSize, MongoConnectionStringBuilder.DefaultMaximumPoolSize);
Assert.AreEqual(builder.MinimumPoolSize, MongoConnectionStringBuilder.DefaultMinimumPoolSize);
Assert.AreEqual(builder.ConnectionLifetime, MongoConnectionStringBuilder.DefaultConnectionLifeTime);
Assert.AreEqual(builder.ConnectionTimeout, MongoConnectionStringBuilder.DefaultConnectionTimeout);
Assert.AreEqual(builder.Database, MongoConnectionStringBuilder.DefaultDatabase);
Assert.AreEqual(builder.Pooled, MongoConnectionStringBuilder.DefaultPooled);
var servers = new List<MongoServerEndPoint>(builder.Servers);
Assert.AreEqual(1, servers.Count);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, servers[0].Port);
Assert.AreEqual(MongoServerEndPoint.DefaultHost, servers[0].Host);
}
public void TestConnectionStringParsing(){
var builder =
new MongoConnectionStringBuilder(
"Username=testuser;Password=testpassword;Server=testserver:555;ConnectionLifetime=50;MaximumPoolSize=101;MinimumPoolSize=202;Pooled=false;Database=testdatabase");
Assert.AreEqual("testuser", builder.Username);
Assert.AreEqual("testpassword", builder.Password);
Assert.AreEqual("testdatabase", builder.Database);
Assert.AreEqual(101, builder.MaximumPoolSize);
Assert.AreEqual(202, builder.MinimumPoolSize);
Assert.AreEqual(TimeSpan.FromSeconds(50), builder.ConnectionLifetime);
Assert.AreEqual(false, builder.Pooled);
var servers = new List<MongoServerEndPoint>(builder.Servers);
Assert.AreEqual(1, servers.Count);
Assert.AreEqual("testserver", servers[0].Host);
Assert.AreEqual(555, servers[0].Port);
}
public void TestServerCirculationWorks()
{
var builder = new MongoConnectionStringBuilder();
builder.AddServer("localhost", 27017);
builder.AddServer("localhost", 27018);
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection1 = pool.Open();
var connection2 = pool.Open();
var connection3 = pool.Open();
var connection4 = pool.Open();
var connection5 = pool.Open();
Assert.AreEqual(27017, connection1.EndPoint.Port);
Assert.AreEqual(27018, connection2.EndPoint.Port);
Assert.AreEqual(27017, connection3.EndPoint.Port);
Assert.AreEqual(27018, connection4.EndPoint.Port);
Assert.AreEqual(27017, connection5.EndPoint.Port);
}
}
public void TestCleanup()
{
var builder = new MongoConnectionStringBuilder
{
MinimumPoolSize = 0,
ConnectionLifetime = TimeSpan.FromMilliseconds(100)
};
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection1 = pool.Open();
var connection2 = pool.Open();
var connection3 = pool.Open();
pool.Close(connection1);
pool.Close(connection2);
pool.Close(connection3);
Thread.Sleep(300); // ensure lifetime reached
pool.Cleanup();
Assert.AreEqual(0,pool.PoolSize);
}
}
private Mongo ConnectAndAuthenticatedMongo(string username,string password)
{
var builder = new MongoConnectionStringBuilder(_connectionString)
{
Username = username,
Password = password
};
var mongo = new Mongo(builder.ToString());
mongo.Connect();
return mongo;
}
public void TestMinimalPoolSizeIsEnsuredAtStartup()
{
var builder = new MongoConnectionStringBuilder {MinimumPoolSize = 3};
using(var pool = new PooledConnectionFactory(builder.ToString()))
Assert.AreEqual(3, pool.PoolSize);
}
public void TestIfConnectionLifetimeIsReachedItDosenotReturndToPool()
{
var builder = new MongoConnectionStringBuilder
{
ConnectionLifetime = TimeSpan.FromMilliseconds(100)
};
using(var pool = new PooledConnectionFactory(builder.ToString()))
{
var connection = pool.Open();
Thread.Sleep(200); // wait for lifetime reached
pool.Close(connection);
Assert.AreEqual(0, pool.PoolSize);
}
}
public void TestCanCreateFromConnectionString(){
var builder = new MongoConnectionStringBuilder(ConfigurationManager.AppSettings["tests"]) {Database = "tests"};
/*
using(var database = new MongoDatabase(builder.ToString()))
{
}*/
}
public void TestToStringOutputWithDefaultServerPort(){
var builder = new MongoConnectionStringBuilder();
builder.AddServer("testserver");
Assert.AreEqual("Server=testserver", builder.ToString());
}
public void TestToStringOutputWithoutUsernameAndPassword(){
var builder = new MongoConnectionStringBuilder();
builder.AddServer("testserver", 555);
Assert.AreEqual("Server=testserver:555", builder.ToString());
}
public void TestUriStringWithUsenameAndPasswort(){
var builder = new MongoConnectionStringBuilder("mongodb://*****:*****@server");
Assert.AreEqual("username", builder.Username);
Assert.AreEqual("password", builder.Password);
Assert.AreEqual(MongoConnectionStringBuilder.DefaultDatabase, builder.Database);
Assert.AreEqual(1, builder.Servers.Length);
Assert.AreEqual("server", builder.Servers[0].Host);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, builder.Servers[0].Port);
}
public void TestUriWithMultipleServers(){
var builder = new MongoConnectionStringBuilder("mongodb://server1,server2:1234,server3/database");
Assert.AreEqual("database", builder.Database);
Assert.AreEqual(3, builder.Servers.Length);
Assert.AreEqual("server1", builder.Servers[0].Host);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, builder.Servers[0].Port);
Assert.AreEqual("server2", builder.Servers[1].Host);
Assert.AreEqual(1234, builder.Servers[1].Port);
Assert.AreEqual("server3", builder.Servers[2].Host);
Assert.AreEqual(MongoServerEndPoint.DefaultPort, builder.Servers[2].Port);
}
public void TestUriWithPropertys(){
var builder = new MongoConnectionStringBuilder("mongodb://server1/database?pooled=false&connectionlifetime=10");
Assert.AreEqual(false, builder.Pooled);
Assert.AreEqual(10.0, builder.ConnectionLifetime.TotalSeconds);
}
public void TestToStringOutput(){
var builder = new MongoConnectionStringBuilder
{
Password = "******",
Username = "******",
ConnectionLifetime = TimeSpan.FromSeconds(50),
MaximumPoolSize = 101,
MinimumPoolSize = 202,
ConnectionTimeout = TimeSpan.FromSeconds(60)
};
builder.AddServer("testserver1", 555);
builder.AddServer("testserver2");
Assert.AreEqual(
"Username=testusername;Password=testpassword;Server=testserver1:555,testserver2;MaximumPoolSize=101;MinimumPoolSize=202;ConnectionTimeout=60;ConnectionLifetime=50",
builder.ToString());
}
