public void constructor_should_initialize_instance()
{
var subject = new ServerSettings();
subject.HeartbeatInterval.Should().Be(ServerSettings.DefaultHeartbeatInterval);
subject.HeartbeatTimeout.Should().Be(ServerSettings.DefaultHeartbeatTimeout);
}
// constructors
public ServerFactory(ServerSettings settings, IConnectionPoolFactory connectionPoolFactory, IConnectionFactory heartbeatConnectionFactory, IServerListener listener)
{
_settings = Ensure.IsNotNull(settings, "settings");
_connectionPoolFactory = Ensure.IsNotNull(connectionPoolFactory, "connectionPoolFactory");
_heartbeatConnectionFactory = Ensure.IsNotNull(heartbeatConnectionFactory, "heartbeatConnectionFactory");
_listener = listener;
}
public void constructor_should_initialize_instance()
{
var subject = new ServerSettings();
subject.HeartbeatInterval.Should().Be(TimeSpan.FromSeconds(10));
subject.HeartbeatTimeout.Should().Be(TimeSpan.FromSeconds(10));
}
// constructors
public ServerFactory(ClusterConnectionMode clusterConnectionMode, ServerSettings settings, IConnectionPoolFactory connectionPoolFactory, IServerMonitorFactory serverMonitoryFactory, IEventSubscriber eventSubscriber)
{
_clusterConnectionMode = clusterConnectionMode;
_settings = Ensure.IsNotNull(settings, nameof(settings));
_connectionPoolFactory = Ensure.IsNotNull(connectionPoolFactory, nameof(connectionPoolFactory));
_serverMonitorFactory = Ensure.IsNotNull(serverMonitoryFactory, nameof(serverMonitoryFactory));
_eventSubscriber = Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber));
}
// constructors
public ServerFactory(ClusterConnectionMode clusterConnectionMode, ServerSettings settings, IConnectionPoolFactory connectionPoolFactory, IConnectionFactory heartbeatConnectionFactory, IEventSubscriber eventSubscriber)
{
_clusterConnectionMode = clusterConnectionMode;
_settings = Ensure.IsNotNull(settings, "settings");
_connectionPoolFactory = Ensure.IsNotNull(connectionPoolFactory, "connectionPoolFactory");
_heartbeatConnectionFactory = Ensure.IsNotNull(heartbeatConnectionFactory, "heartbeatConnectionFactory");
_eventSubscriber = Ensure.IsNotNull(eventSubscriber, "eventSubscriber");
}
// constructors
public ClusterBuilder()
{
_clusterSettings = new ClusterSettings();
_serverSettings = new ServerSettings();
_connectionPoolSettings = new ConnectionPoolSettings();
_connectionSettings = new ConnectionSettings();
_tcpStreamSettings = new TcpStreamSettings();
_streamFactoryWrapper = inner => inner;
}
public void constructor_with_heartbeatTimeout_should_initialize_instance()
{
var heartbeatTimeout = TimeSpan.FromSeconds(123);
var subject = new ServerSettings(heartbeatTimeout: heartbeatTimeout);
subject.HeartbeatInterval.Should().Be(ServerSettings.DefaultHeartbeatInterval);
subject.HeartbeatTimeout.Should().Be(heartbeatTimeout);
}
public void WithHeartbeatTimeout_returns_new_instance_if_value_is_not_equal()
{
var oldHeartbeatTimeout = TimeSpan.FromSeconds(1);
var newHeartbeatTimeout = TimeSpan.FromSeconds(2);
var subject1 = new ServerSettings().WithHeartbeatTimeout(oldHeartbeatTimeout);
var subject2 = subject1.WithHeartbeatTimeout(newHeartbeatTimeout);
subject2.Should().NotBeSameAs(subject1);
subject2.HeartbeatTimeout.Should().Be(newHeartbeatTimeout);
}
public ServerFactoryTests()
{
_clusterId = new ClusterId();
_clusterConnectionMode = ClusterConnectionMode.Standalone;
_connectionPoolFactory = new Mock<IConnectionPoolFactory>().Object;
_endPoint = new DnsEndPoint("localhost", 27017);
_serverMonitorFactory = new Mock<IServerMonitorFactory>().Object;
_eventSubscriber = new Mock<IEventSubscriber>().Object;
_settings = new ServerSettings();
}
// static constructor
static ClusterKey()
{
var defaultServerSettings = new ServerSettings();
__defaultHeartbeatInterval = defaultServerSettings.HeartbeatInterval;
__defaultHeartbeatTimeout = defaultServerSettings.HeartbeatTimeout;
var defaultTcpStreamSettings = new TcpStreamSettings();
__defaultReceiveBufferSize = defaultTcpStreamSettings.ReceiveBufferSize;
__defaultSendBufferSize = defaultTcpStreamSettings.SendBufferSize;
}
public void Setup()
{
_clusterId = new ClusterId();
_clusterConnectionMode = ClusterConnectionMode.Standalone;
_connectionPoolFactory = Substitute.For<IConnectionPoolFactory>();
_endPoint = new DnsEndPoint("localhost", 27017);
_heartbeatConnectionFactory = Substitute.For<IConnectionFactory>();
_eventSubscriber = Substitute.For<IEventSubscriber>();
_settings = new ServerSettings();
}
public void With_heartbeatInterval_should_return_expected_result()
{
var oldHeartbeatInterval = TimeSpan.FromSeconds(1);
var newHeartbeatInterval = TimeSpan.FromSeconds(2);
var subject = new ServerSettings(heartbeatInterval: oldHeartbeatInterval);
var result = subject.With(heartbeatInterval: newHeartbeatInterval);
result.HeartbeatInterval.Should().Be(newHeartbeatInterval);
result.HeartbeatTimeout.Should().Be(subject.HeartbeatTimeout);
}
public void Setup()
{
_clusterId = new ClusterId();
_clusterConnectionMode = ClusterConnectionMode.Standalone;
_connectionPool = Substitute.For<IConnectionPool>();
_connectionPoolFactory = Substitute.For<IConnectionPoolFactory>();
_connectionPoolFactory.CreateConnectionPool(null, null)
.ReturnsForAnyArgs(_connectionPool);
_endPoint = new DnsEndPoint("localhost", 27017);
_heartbeatConnection = new MockConnection();
_heartbeatConnectionFactory = Substitute.For<IConnectionFactory>();
_heartbeatConnectionFactory.CreateConnection(null, null)
.ReturnsForAnyArgs(_heartbeatConnection);
_capturedEvents = new EventCapturer();
_settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan);
_subject = new ClusterableServer(_clusterId, _clusterConnectionMode, _settings, _endPoint, _connectionPoolFactory, _heartbeatConnectionFactory, _capturedEvents);
}
public ServerTests()
{
_clusterId = new ClusterId();
_endPoint = new DnsEndPoint("localhost", 27017);
_clusterConnectionMode = ClusterConnectionMode.Standalone;
_mockConnectionPool = new Mock<IConnectionPool>();
_mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny<CancellationToken>())).Returns(new Mock<IConnectionHandle>().Object);
_mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(new Mock<IConnectionHandle>().Object));
_mockConnectionPoolFactory = new Mock<IConnectionPoolFactory>();
_mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny<ServerId>(), _endPoint))
.Returns(_mockConnectionPool.Object);
_mockServerMonitor = new Mock<IServerMonitor>();
_mockServerMonitorFactory = new Mock<IServerMonitorFactory>();
_mockServerMonitorFactory.Setup(f => f.Create(It.IsAny<ServerId>(), _endPoint)).Returns(_mockServerMonitor.Object);
_capturedEvents = new EventCapturer();
_settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan);
_subject = new Server(_clusterId, _clusterConnectionMode, _settings, _endPoint, _mockConnectionPoolFactory.Object, _mockServerMonitorFactory.Object, _capturedEvents);
}
// constructors
public Builder(ServerSettings other)
{
_heartbeatInterval = other._heartbeatInterval;
_heartbeatTimeout = other._heartbeatTimeout;
}
private ServerSettings ConfigureServer(ServerSettings settings, ClusterKey clusterKey)
{
return settings.With(
heartbeatInterval: clusterKey.HeartbeatInterval,
heartbeatTimeout: clusterKey.HeartbeatTimeout);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerOpenedEvent"/> struct.
/// </summary>
/// <param name="serverId">The server identifier.</param>
/// <param name="serverSettings">The server settings.</param>
/// <param name="duration">The duration of time it took to open the server.</param>
public ServerOpenedEvent(ServerId serverId, ServerSettings serverSettings, TimeSpan duration)
{
_serverId = serverId;
_serverSettings = serverSettings;
_duration = duration;
}
public void Setup()
{
_clusterId = new ClusterId();
_connectionPool = Substitute.For<IConnectionPool>();
_connectionPoolFactory = Substitute.For<IConnectionPoolFactory>();
_connectionPoolFactory.CreateConnectionPool(null, null)
.ReturnsForAnyArgs(_connectionPool);
_endPoint = new DnsEndPoint("localhost", 27017);
_heartbeatConnection = new MockConnection();
_heartbeatConnectionFactory = Substitute.For<IConnectionFactory>();
_heartbeatConnectionFactory.CreateConnection(null, null)
.ReturnsForAnyArgs(_heartbeatConnection);
_listener = Substitute.For<IServerListener>();
_settings = new ServerSettings()
.WithHeartbeatInterval(Timeout.InfiniteTimeSpan);
_subject = new ClusterableServer(_settings, _clusterId, _endPoint, _connectionPoolFactory, _heartbeatConnectionFactory, _listener);
}
public void ServerAfterOpening(ServerId serverId, ServerSettings settings, TimeSpan elapsed)
{
_first.ServerAfterOpening(serverId, settings, elapsed);
_second.ServerAfterOpening(serverId, settings, elapsed);
}
public ClusterBuilder ConfigureServer(Func<ServerSettings, ServerSettings> configure)
{
_serverSettings = configure(_serverSettings);
return this;
}
// constructors
public Builder(ServerSettings other)
{
_heartbeatInterval = other._heartbeatInterval;
_heartbeatTimeout = other._heartbeatTimeout;
}
public void WithHeartbeatTimeout_returns_same_instance_if_value_is_equal()
{
var subject1 = new ServerSettings();
var subject2 = subject1.WithHeartbeatTimeout(subject1.HeartbeatTimeout);
subject2.Should().BeSameAs(subject1);
}
public ServerMonitorFactory(ServerSettings settings, IConnectionFactory connectionFactory, IEventSubscriber eventSubscriber)
{
_settings = Ensure.IsNotNull(settings, nameof(settings));
_connectionFactory = Ensure.IsNotNull(connectionFactory, nameof(connectionFactory));
_eventSubscriber = Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber));
}
public void Setup()
{
_clusterId = new ClusterId();
_connectionPoolFactory = Substitute.For<IConnectionPoolFactory>();
_endPoint = new DnsEndPoint("localhost", 27017);
_heartbeatConnectionFactory = Substitute.For<IConnectionFactory>();
_listener = Substitute.For<IServerListener>();
_settings = new ServerSettings();
}
/// <summary>
/// Configures the server settings.
/// </summary>
/// <param name="configurator">The server settings configurator delegate.</param>
/// <returns>A reconfigured cluster builder.</returns>
public ClusterBuilder ConfigureServer(Func <ServerSettings, ServerSettings> configurator)
{
_serverSettings = configurator(_serverSettings);
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerOpeningEvent"/> struct.
/// </summary>
/// <param name="serverId">The server identifier.</param>
/// <param name="serverSettings">The server settings.</param>
public ServerOpeningEvent(ServerId serverId, ServerSettings serverSettings)
{
_serverId = serverId;
_serverSettings = serverSettings;
}
public void ServerBeforeOpening(ServerId serverId, ServerSettings settings)
{
_first.ServerBeforeOpening(serverId, settings);
_second.ServerBeforeOpening(serverId, settings);
}
