public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_manager = new UsersManager(new NoopLogger(), _node.ExtHttpEndPoint, TimeSpan.FromSeconds(5));
}
public void should_return_stream_not_found()
{
const string stream1 = "account--696193173";
const string stream2 = "LPN-FC002_LPK51001";
using (var store = BuildConnection(_node))
{
store.ConnectAsync().Wait();
//Write event to stream 1
Assert.AreEqual(0, store.AppendToStreamAsync(stream1, ExpectedVersion.EmptyStream, new EventData(Guid.NewGuid(), "TestEvent", true, null, null)).Result.NextExpectedVersion);
//Write 100 events to stream 2 which will have the same hash as stream 1.
for(int i = 0; i < 100; i++){
Assert.AreEqual(i, store.AppendToStreamAsync(stream2, ExpectedVersion.Any, new EventData(Guid.NewGuid(), "TestEvent", true, null, null)).Result.NextExpectedVersion);
}
}
var tcpPort = _node.TcpEndPoint.Port;
var tcpSecPort = _node.TcpSecEndPoint.Port;
var httpPort = _node.ExtHttpEndPoint.Port;
_node.Shutdown(keepDb: true, keepPorts: true);
//Restart the node to ensure the read index stream info cache is empty
_node = new MiniNode(PathName,
tcpPort, tcpSecPort, httpPort, inMemDb: false,
memTableSize: 20,
hashCollisionReadLimit: 1,
indexBitnessVersion: EventStore.Core.Index.PTableVersions.Index32Bit);
_node.Start();
using (var store = BuildConnection(_node))
{
store.ConnectAsync().Wait();
Assert.AreEqual(SliceReadStatus.StreamNotFound, store.ReadStreamEventsForwardAsync(stream1, 0, 1, true).Result.Status);
}
}
protected void CreateNode()
{
var projections = new ProjectionsSubsystem(1, runProjections: ProjectionType.All, startStandardProjections: false);
Node = new MiniNode(
PathName, inMemDb: true, skipInitializeStandardUsersCheck: false, subsystems: new ISubsystem[] { projections });
Node.Start();
}
public void TearDown()
{
_connection.Close();
_node.Shutdown();
_connection = null;
_node = null;
_directory.TestFixtureTearDown();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_conn = EventStoreConnection.Create(_node.TcpEndPoint);
_conn.ConnectAsync().Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
When();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = BuildConnection(_node);
_connection.ConnectAsync().Wait();
}
public void TearDown()
{
Connection.Close();
Node.Shutdown();
Connection = null;
Node = null;
Directory.Delete(PathName, true);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName,
inMemDb: false,
memTableSize: 20,
hashCollisionReadLimit: 1,
indexBitnessVersion: EventStore.Core.Index.PTableVersions.Index32Bit);
_node.Start();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
_testEvents = Enumerable.Range(0, 5).Select(x => TestEvent.NewTestEvent(data: x.ToString())).ToArray();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_HttpEndPoint = _node.HttpEndPoint;
_conn = BuildConnection(_node);
_conn.ConnectAsync().Wait();
Given();
When();
}
public void SetUp()
{
WebRequest.DefaultWebProxy = new WebProxy();
_counter = 0;
_directory = new SpecificationWithDirectoryPerTestFixture();
_directory.TestFixtureSetUp();
_node = new MiniNode(_directory.PathName, skipInitializeStandardUsersCheck: false, enableTrustedAuth: true);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_credentials = new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword);
var createdMiniNode = false;
_timeout = TimeSpan.FromSeconds(10);
// Check if a node is running in ProjectionsManagerTestSuiteMarkerBase
if (SetUpFixture.Connection != null && SetUpFixture.Node != null)
{
_tag = "_" + (++SetUpFixture.Counter);
_node = SetUpFixture.Node;
_connection = SetUpFixture.Connection;
}
else
{
createdMiniNode = true;
_tag = "_1";
_node = CreateNode();
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
try
{
_projManager = new ProjectionsManager(new ConsoleLogger(), _node.ExtHttpEndPoint, _timeout);
Given();
When();
}
catch
{
if (createdMiniNode)
{
if (_connection != null)
{
try {
_connection.Close();
} catch {
}
}
if (_node != null)
{
try {
_node.Shutdown();
} catch {
}
}
}
throw;
}
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.ConnectAsync().Wait();
_conn.SetStreamMetadataAsync("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword)).Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
var scavengeMessage = new ClientMessage.ScavengeDatabase(new NoopEnvelope(), Guid.NewGuid(), SystemAccount.Principal);
_node.Node.MainQueue.Publish(scavengeMessage);
When();
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
_connection.SetStreamMetadataAsync(Stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetMaxCount(3)).Wait();
_testEvents = Enumerable.Range(0, 5).Select(x => TestEvent.NewTestEvent(data: x.ToString())).ToArray();
_connection.AppendToStreamAsync(Stream, ExpectedVersion.EmptyStream, _testEvents).Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_conn.SetStreamMetadata("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword));
_testEvents = Enumerable.Range(0, 20).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray();
_conn.AppendToStream("stream", ExpectedVersion.EmptyStream, _testEvents);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, inMemDb: true);
_node.Start();
_conn = BuildConnection(_node);
_conn.ConnectAsync().Wait();
//Create 80000 events
for(var i = 0; i < 80; i++)
{
_conn.AppendToStreamAsync(_streamName, ExpectedVersion.Any, CreateThousandEvents()).Wait();
}
_settings = new CatchUpSubscriptionSettings(100, 1, false, true);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_eventId0 = Guid.NewGuid();
_eventId1 = Guid.NewGuid();
_conn.AppendToStream("test-stream",
-1,
new EventData(_eventId0, "event0", false, new byte[3], new byte[2]),
new EventData(_eventId1, "event1", false, new byte[7], new byte[10]));
_conn.DeleteStream("deleted-stream", -1, hardDelete: true);
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = EventStoreConnection.Create();
_connection.Connect(_node.TcpEndPoint);
_connection.AppendToStream("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent());
using (var transaction = _connection.StartTransaction("test-stream", 3))
{
transaction.Commit();
}
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
Assert.AreEqual(2, _connection.AppendToStream("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent()).NextExpectedVersion);
using (var transaction = _connection.StartTransaction("test-stream", 2))
{
Assert.AreEqual(2, transaction.Commit().NextExpectedVersion);
}
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = BuildConnection(_node);
_connection.ConnectAsync().Wait();
Assert.AreEqual(2, _connection.AppendToStreamAsync("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent()).Result.NextExpectedVersion);
using (var transaction = _connection.StartTransactionAsync("test-stream", 2).Result)
{
Assert.AreEqual(2, transaction.CommitAsync().Result.NextExpectedVersion);
}
}
public override void TestFixtureTearDown()
{
_node.Shutdown();
_node = null;
base.TestFixtureTearDown();
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
}
public static IEventStoreConnection To(MiniNode miniNode, TcpType tcpType, UserCredentials userCredentials = null)
{
return(EventStoreConnection.Create(Settings(tcpType, userCredentials),
tcpType == TcpType.Ssl ? miniNode.TcpSecEndPoint : miniNode.TcpEndPoint,
string.Format("ESC-{0}", Interlocked.Increment(ref _nextConnId))));
}
public override void TestFixtureSetUp()
{
#if !__MonoCS__
Helper.EatException(() => _dumpResponse = CreateDumpResponse());
Helper.EatException(() => _dumpResponse2 = CreateDumpResponse2());
Helper.EatException(() => _dumpRequest = CreateDumpRequest());
Helper.EatException(() => _dumpRequest2 = CreateDumpRequest2());
#endif
base.TestFixtureSetUp();
bool createdMiniNode = false;
if (SetUpFixture._connection != null && SetUpFixture._node != null)
{
_tag = "_" + (++SetUpFixture._counter);
_node = SetUpFixture._node;
_connection = SetUpFixture._connection;
}
else
{
createdMiniNode = true;
_tag = "_1";
_node = CreateMiniNode();
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
_lastResponse = null;
_lastResponseBody = null;
_lastResponseBytes = null;
_lastJsonException = null;
try
{
Given();
When();
}
catch
{
if (createdMiniNode)
{
if (_connection != null)
{
try
{
_connection.Close();
}
catch
{
}
}
if (_node != null)
{
try
{
_node.Shutdown();
}
catch
{
}
}
}
throw;
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, enableTrustedAuth: true);
try
{
_node.Start();
var userCreateEvent1 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent1.Set();
}),
SystemAccount.Principal,
"user1",
"Test User 1",
new string[0],
"pa$$1"));
var userCreateEvent2 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent2.Set();
}),
SystemAccount.Principal,
"user2",
"Test User 2",
new string[0],
"pa$$2"));
var adminCreateEvent2 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
adminCreateEvent2.Set();
}),
SystemAccount.Principal,
"adm",
"Administrator User",
new[] { SystemRoles.Admins },
"admpa$$"));
Assert.IsTrue(userCreateEvent1.Wait(10000), "User 1 creation failed");
Assert.IsTrue(userCreateEvent2.Wait(10000), "User 2 creation failed");
Assert.IsTrue(adminCreateEvent2.Wait(10000), "Administrator User creation failed");
Connection = TestConnection.Create(_node.TcpEndPoint, TcpType.Normal, _userCredentials);
Connection.ConnectAsync().Wait();
Connection.SetStreamMetadataAsync("noacl-stream", ExpectedVersion.NoStream, StreamMetadata.Build())
.Wait();
Connection.SetStreamMetadataAsync(
"read-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetReadRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
"write-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
"metaread-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetMetadataReadRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
"metawrite-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetMetadataWriteRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
"$all",
ExpectedVersion.Any,
StreamMetadata.Build().SetReadRole("user1"),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
"$system-acl",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole("user1")
.SetWriteRole("user1")
.SetMetadataReadRole("user1")
.SetMetadataWriteRole("user1"),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
"$system-adm",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.Admins)
.SetWriteRole(SystemRoles.Admins)
.SetMetadataReadRole(SystemRoles.Admins)
.SetMetadataWriteRole(SystemRoles.Admins),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
"normal-all",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All)).Wait();
Connection.SetStreamMetadataAsync(
"$system-all",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All),
new UserCredentials("adm", "admpa$$")).Wait();
}
catch
{
if (_node != null)
{
try
{
_node.Shutdown();
}
catch
{
}
}
throw;
}
}
protected override IEventStoreConnection BuildConnection(MiniNode node)
{
return EmbeddedTestConnection.To(node);
}
protected virtual IEventStoreConnection BuildConnection(MiniNode node)
{
return EventStoreConnection.Create(node.TcpEndPoint.ToESTcpUri());
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_node = new MiniNode(PathName, enableTrustedAuth: true);
await _node.Start();
var userCreateEvent1 = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m => {
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent1.SetResult(true);
}),
SystemAccounts.System,
"user1",
"Test User 1",
new string[0],
"pa$$1"));
var userCreateEvent2 = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m => {
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent2.SetResult(true);
}),
SystemAccounts.System,
"user2",
"Test User 2",
new string[0],
"pa$$2"));
var adminCreateEvent2 = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m => {
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
adminCreateEvent2.SetResult(true);
}),
SystemAccounts.System,
"adm",
"Administrator User",
new[] { SystemRoles.Admins },
"admpa$$"));
Assert.IsTrue(await userCreateEvent1.Task.WithTimeout(10000), "User 1 creation failed");
Assert.IsTrue(await userCreateEvent2.Task.WithTimeout(10000), "User 2 creation failed");
Assert.IsTrue(await adminCreateEvent2.Task.WithTimeout(10000), "Administrator User creation failed");
Connection = SetupConnection(_node);
await Connection.ConnectAsync();
await Connection.SetStreamMetadataAsync("noacl-stream", ExpectedVersion.NoStream, StreamMetadata.Build());
await Connection.SetStreamMetadataAsync(
"read-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetReadRole("user1"));
await Connection.SetStreamMetadataAsync(
"write-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole("user1"));
await Connection.SetStreamMetadataAsync(
"metaread-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetMetadataReadRole("user1"));
await Connection.SetStreamMetadataAsync(
"metawrite-stream",
ExpectedVersion.NoStream,
StreamMetadata.Build().SetMetadataWriteRole("user1"));
await Connection.SetStreamMetadataAsync(
"$all",
ExpectedVersion.Any,
StreamMetadata.Build().SetReadRole("user1"),
new UserCredentials("adm", "admpa$$"));
await Connection.SetStreamMetadataAsync(
"$system-acl",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole("user1")
.SetWriteRole("user1")
.SetMetadataReadRole("user1")
.SetMetadataWriteRole("user1"),
new UserCredentials("adm", "admpa$$"));
await Connection.SetStreamMetadataAsync(
"$system-adm",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.Admins)
.SetWriteRole(SystemRoles.Admins)
.SetMetadataReadRole(SystemRoles.Admins)
.SetMetadataWriteRole(SystemRoles.Admins),
new UserCredentials("adm", "admpa$$"));
await Connection.SetStreamMetadataAsync(
"normal-all",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All));
await Connection.SetStreamMetadataAsync(
"$system-all",
ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All),
new UserCredentials("adm", "admpa$$"));
}
protected virtual IEventStoreConnection BuildConnection(MiniNode <TLogFormat, TStreamId> node)
{
return(TestConnection <TLogFormat, TStreamId> .To(node, TcpType.Ssl));
}
public static IEventStoreConnection To(MiniNode miniNode, UserCredentials credentials = null)
{
return(EmbeddedEventStoreConnection.Create(miniNode.Node, Settings(credentials),
string.Format("ESC-{0}", Interlocked.Increment(ref _nextConnId))));
}
protected virtual IEventStoreConnection BuildConnection(MiniNode node)
{
return(TestConnection.Create(node.TcpEndPoint));
}
protected virtual IEventStoreConnection BuildConnection(MiniNode node)
{
return(TestConnection.To(node, TcpType.Normal));
}
protected void ShutdownNode()
{
_node.Shutdown(keepDb: true, keepPorts: true);
_node = null;
}
public virtual IEventStoreConnection SetupConnection(MiniNode node)
{
return(TestConnection.Create(node.TcpEndPoint, TcpType.Normal, _userCredentials));
}
public void SetUp()
{
_node = new MiniNode <TLogFormat, TStreamId>(PathName);
}
public void SetUp()
{
Node = MiniNode.Create(40111, 40112);
Node.Start();
}
public static IEventStoreConnection To(MiniNode miniNode, TcpType tcpType, UserCredentials userCredentials = null)
{
return EventStoreConnection.Create(Settings(tcpType, userCredentials),
tcpType == TcpType.Ssl ? miniNode.TcpSecEndPoint.ToESTcpUri() : miniNode.TcpEndPoint.ToESTcpUri(),
string.Format("ESC-{0}", Interlocked.Increment(ref _nextConnId)));
}
public static IEventStoreConnection To(MiniNode miniNode, TcpType tcpType, UserCredentials userCredentials = null)
{
return(EventStoreConnection.Create(Settings(tcpType, userCredentials),
tcpType == TcpType.Ssl ? miniNode.TcpSecEndPoint : miniNode.TcpEndPoint));
}
public static IEventStoreConnection To(MiniNode miniNode)
{
return EmbeddedEventStoreConnection.Create(miniNode.Node, Settings(),
string.Format("ESC-{0}", Interlocked.Increment(ref _nextConnId)));
}
virtual protected IEventStoreConnection BuildConnection(MiniNode node)
{
return TestConnection.Create(node.TcpEndPoint);
}
protected override IEventStoreConnection BuildConnection(MiniNode node)
{
return(EmbeddedTestConnection.To(node));
}
