public TestRegistry()
{
var noIp = new IPEndPoint(IPAddress.None, 0);
ClusterVNode node = EmbeddedVNodeBuilder
.AsSingleNode()
.WithInternalTcpOn(noIp)
.WithInternalHttpOn(noIp)
.RunInMemory()
.Build();
var connection = EmbeddedEventStoreConnection.Create(node);
For <ClusterVNode>()
.Singleton()
.Use(node);
For <IEventStoreConnection>()
.Singleton()
.Use(connection);
For <EventStoreUnitOfWork>()
.HybridHttpOrThreadLocalScoped()
.Use <TestUnitOfWork>()
.Ctor <IEventEmitter>()
.Is(c => c.GetInstance <IEventEmitter>())
;
//For<IEventRepository>()
// .Use(c => c.GetInstance<TestUnitOfWork>().EventRepository)
// ;
For <NHibernateUnitOfWork>()
.HybridHttpOrThreadLocalScoped()
.Use <NHibernateUnitOfWork>();
}
public async Task What_happens_when_a_stream_is_deleted()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
using (await connection.SubscribeToStreamAsync("stream-1", true, PrintEvent))
{
await connection.AppendToStreamAsync("stream-1",
ExpectedVersion.Any,
new EventData(Guid.NewGuid(), "event", true, Encoding.UTF8.GetBytes("{}"), null));
await connection.DeleteStreamAsync("stream-1", global::EventStore.ClientAPI.ExpectedVersion.Any);
await Task.Delay(1000);
}
using (await connection.SubscribeToAllAsync(true, PrintEvent))
{
await connection.AppendToStreamAsync("stream-2",
ExpectedVersion.Any,
new EventData(Guid.NewGuid(), "myevent", true, Encoding.UTF8.GetBytes("{}"), null));
await connection.DeleteStreamAsync("stream-2", global::EventStore.ClientAPI.ExpectedVersion.Any);
await Task.Delay(1000);
}
}
}
private Func <IEventStoreConnection> BuildConnectionBuilder()
{
return(() =>
{
var wait = new ManualResetEventSlim(false);
_node.NodeStatusChanged += (sender, args) =>
{
if (args.NewVNodeState == VNodeState.Master)
{
wait.Set();
}
};
_node.Start();
if (!wait.Wait(20000))
{
throw new TimeoutException("Node has not started in 20 seconds.");
}
StartProjections(_projections.MainQueue);
_startup(_node);
return EmbeddedEventStoreConnection.Create(_node);
});
}
public async Task Delete(string name, bool hardDelete)
{
using (var cn = EmbeddedEventStoreConnection.Create(_node))
{
await cn.DeleteStreamAsync(name, ExpectedVersion.Any, hardDelete);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(ctx => {
var log = ctx.GetService <ILogger <Startup> >();
//RESEARCH: Should this be in a hosted service instead?
var nodeBuilder = EmbeddedVNodeBuilder.AsSingleNode()
.DisableExternalTls()
.DisableInternalTls()
.WithInternalHttpOn(new IPEndPoint(IPAddress.Loopback, 1112))
.WithInternalTcpOn(new IPEndPoint(IPAddress.Loopback, 1113))
.DisableDnsDiscovery()
.WithGossipSeeds(new IPEndPoint[] {
new IPEndPoint(IPAddress.Loopback, 2112),
new IPEndPoint(IPAddress.Loopback, 3112)
})
.EnableTrustedAuth()
.RunInMemory();
Node = nodeBuilder.Build();
Node.StartAsync(true).Wait();
var conn = EmbeddedEventStoreConnection.Create(Node,
ConnectionSettings.Create()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
.Build());
conn.ConnectAsync().Wait(TimeSpan.FromSeconds(30));
return(conn);
});
services.AddRazorPages();
services.AddServerSideBlazor();
services.AddSingleton <WeatherForecastService>();
}
public void Establish()
{
s_eventStoreNodeStarted = false;
s_eventStoreClientConnected = false;
var noneIp = new IPEndPoint(IPAddress.None, 0);
s_eventStoreNode = EmbeddedVNodeBuilder
.AsSingleNode()
.RunInMemory()
.WithExternalTcpOn(noneIp)
.WithInternalTcpOn(noneIp)
.WithExternalHttpOn(noneIp)
.WithInternalHttpOn(noneIp)
.Build();
s_eventStoreNode.NodeStatusChanged +=
(sender, e) => { if (e.NewVNodeState == VNodeState.Master)
{
s_eventStoreNodeStarted = true;
}
};
s_eventStoreNode.Start();
s_eventStore = EmbeddedEventStoreConnection.Create(s_eventStoreNode);
s_eventStore.Connected += (sender, e) => { s_eventStoreClientConnected = true; };
s_eventStore.ConnectAsync().Wait();
s_eventStoreMessageStore = new EventStoreMessageStore(s_eventStore);
EnsureEventStoreNodeHasStartedAndTheClientHasConnected();
}
public ResolvedEventtDispatcherTests()
{
var source = new TaskCompletionSource <bool>();
_nodeStarted = source.Task;
var notListening = new IPEndPoint(IPAddress.None, 0);
_node = EmbeddedVNodeBuilder.AsSingleNode()
.WithInternalTcpOn(notListening)
.WithExternalTcpOn(notListening)
.WithInternalHttpOn(notListening)
.WithExternalHttpOn(notListening);
_node.NodeStatusChanged += (_, e) =>
{
if (e.NewVNodeState != VNodeState.Master)
{
return;
}
source.SetResult(true);
};
_node.Start();
_connection = EmbeddedEventStoreConnection.Create(_node);
}
public static World AddWorld(this IServiceCollection services,
ClusterVNode clusterVNode,
ConnectionSettings connectionSettings,
Action <IEventStoreRepositoryConfiguration> getEventStoreRepositoryConfiguration = null)
{
var eventStoreConnection = EmbeddedEventStoreConnection.Create(clusterVNode, connectionSettings);
services.AddSingleton <IConnectionStatusMonitor <IEventStoreConnection>, EventStoreConnectionStatusMonitor>();
services.AddSingleton(eventStoreConnection);
services.AddSingleton(connectionSettings);
var eventStoreRepositoryConfiguration = new EventStoreRepositoryConfiguration();
getEventStoreRepositoryConfiguration?.Invoke(eventStoreRepositoryConfiguration);
services.AddSingleton <IEventStoreRepositoryConfiguration>(eventStoreRepositoryConfiguration);
services.AddTransient <IEventStoreRepository, EventStoreRepository>();
var world = new World(services, true);
services.AddSingleton(world);
return(world);
}
public async Task Read_stream_backwards()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
string streamId = "stream-1";
var eventData = new[]
{
new EventData(Guid.NewGuid(), "type", false, null, null),
new EventData(Guid.NewGuid(), "type", false, null, null),
new EventData(Guid.NewGuid(), "type", false, null, null),
new EventData(Guid.NewGuid(), "type", false, null, null),
new EventData(Guid.NewGuid(), "type", false, null, null),
new EventData(Guid.NewGuid(), "type", false, null, null),
};
await connection.AppendToStreamAsync(streamId, ExpectedVersion.NoStream, eventData);
var allEventsSlice = await connection.ReadStreamEventsBackwardAsync(streamId, StreamPosition.End, 2, true);
allEventsSlice = await connection.ReadStreamEventsBackwardAsync(streamId, allEventsSlice.NextEventNumber, 2, true);
_testOutputHelper.WriteLine($"LastEventNumber {allEventsSlice.LastEventNumber}");
_testOutputHelper.WriteLine($"NextEventNumber {allEventsSlice.NextEventNumber}");
_testOutputHelper.WriteLine($"FromEventNumber {allEventsSlice.FromEventNumber}");
foreach (var resolvedEvent in allEventsSlice.Events)
{
_testOutputHelper.WriteLine(
$"{resolvedEvent.OriginalStreamId} {resolvedEvent.OriginalEventNumber} " +
$"{resolvedEvent.Event.EventType} {resolvedEvent.OriginalEvent.EventType}");
}
}
}
public static EventStoreStatelessActorBuilder <TActor, TRegistry> Create(
ClusterVNode clusterVNode,
ConnectionSettings connectionSettings,
IActorConfiguration actorConfiguration,
ILoggerFactory?loggerFactory = null,
Action <IEventStoreRepositoryConfiguration>?getEventStoreRepositoryConfiguration = null)
{
var connection = EmbeddedEventStoreConnection.Create(clusterVNode, connectionSettings);
loggerFactory ??= new DummyLoggerFactory();
var eventStoreRepositoryConfiguration = new EventStoreRepositoryConfiguration();
getEventStoreRepositoryConfiguration?.Invoke(eventStoreRepositoryConfiguration);
var connectionStatusMonitor = new EventStoreConnectionStatusMonitor(connection, loggerFactory);
var eventStoreRepository = new EventStoreRepository(
eventStoreRepositoryConfiguration,
connection,
connectionStatusMonitor,
loggerFactory);
var eventStoreStatelessActorBuilder = new EventStoreStatelessActorBuilder <TActor, TRegistry>(actorConfiguration, eventStoreRepository, connectionStatusMonitor, loggerFactory);
return(eventStoreStatelessActorBuilder);
}
public IEventStoreConnection Build()
{
ClusterVNode node = new InMemoryEventStore().Instance;
IEventStoreConnection eventStoreConnection = EmbeddedEventStoreConnection.Create(node);
return(eventStoreConnection);
}
public static void Start()
{
var node = EmbeddedVNodeBuilder.
AsSingleNode().
OnDefaultEndpoints().
RunInMemory().
Build();
node.Start();
var tcs = new TaskCompletionSource <object>();
node.NodeStatusChanged += (sender, args) =>
{
if (args.NewVNodeState == VNodeState.Master)
{
tcs.SetResult(null);
}
};
tcs.Task.Wait();
Node = node;
Credentials = new UserCredentials("admin", "changeit");
var connection = EmbeddedEventStoreConnection.Create(Node);
// This does not work, because ... ††† JEZUS †††
//var connection = EventStoreConnection.Create(
// ConnectionSettings.Create().SetDefaultUserCredentials(Credentials).UseDebugLogger(),
// new IPEndPoint(Opts.InternalIpDefault, Opts.ExternalTcpPortDefault));
connection.ConnectAsync().Wait();
Connection = connection;
}
public EventStoreFixture()
{
_node = EmbeddedVNodeBuilder
.AsSingleNode()
.OnDefaultEndpoints()
.RunInMemory()
.DisableDnsDiscovery()
.DisableHTTPCaching()
//.DisableScavengeMerging()
.DoNotVerifyDbHashes()
.Build();
_node.StartAndWaitUntilReady().Wait();
var conns = ConnectionSettings.Create()
.SetDefaultUserCredentials(new EventStore.ClientAPI.SystemData.UserCredentials("admin", "changeit"))
.Build();
var eventStoreConnection = EmbeddedEventStoreConnection.Create(_node, conns);
StreamStoreConnection = new EventStoreConnectionWrapper(eventStoreConnection);
EventSerializer = new JsonMessageSerializer();
StreamNameBuilder = new PrefixedCamelCaseStreamNameBuilder("masterdata");
_repo = new StreamStoreRepository(StreamNameBuilder, StreamStoreConnection, EventSerializer);
}
public GetEventStoreAggregateRepositoryTests()
{
_id = "aggregate-" + Guid.NewGuid().ToString("n");
var source = new TaskCompletionSource <bool>();
_eventStoreInitialized = source.Task;
var notListening = new IPEndPoint(IPAddress.None, 0);
_node = EmbeddedVNodeBuilder
.AsSingleNode()
.WithExternalTcpOn(notListening)
.WithInternalTcpOn(notListening)
.WithExternalHttpOn(notListening)
.WithInternalHttpOn(notListening)
.RunProjections(ProjectionsMode.All);
_node.NodeStatusChanged += (_, e) =>
{
if (e.NewVNodeState != VNodeState.Master)
{
return;
}
source.SetResult(true);
};
_connection = EmbeddedEventStoreConnection.Create(_node);
_sut = new GetEventStoreAggregateRepository(_connection, new DefaultGetEventStoreJsonSerializer());
_node.Start();
}
public async Task Catchup_subscription()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
string streamId = "stream-1";
var eventData = new EventData(Guid.NewGuid(), "type-1", false, null, null);
await connection.AppendToStreamAsync(streamId, ExpectedVersion.NoStream, eventData);
var subscription = connection.SubscribeToStreamFrom(streamId,
null,
false,
(_, resolvedEvent) =>
{
_testOutputHelper.WriteLine($"Sub {resolvedEvent.OriginalEvent.EventNumber} {resolvedEvent.OriginalEvent.EventType}");
});
var eventData2 = new EventData(Guid.NewGuid(), "type-2", false, null, null);
await connection.AppendToStreamAsync(streamId, ExpectedVersion.Any, eventData2);
await Task.Delay(2000);
var messagesSlice = await connection.ReadStreamEventsForwardAsync(streamId, StreamPosition.Start, 10, true);
foreach (var resolvedEvent in messagesSlice.Events)
{
_testOutputHelper.WriteLine($"Slice {resolvedEvent.OriginalEvent.EventNumber} {resolvedEvent.OriginalEvent.EventType}");
}
subscription.Stop();
}
}
public an_evenstore_connection()
{
_node = EmbeddedVNodeBuilder.AsSingleNode().OnDefaultEndpoints().RunInMemory().Build();
_node.StartAndWaitUntilReady().Wait();
Connection = EmbeddedEventStoreConnection.Create(_node);
Connection.ConnectAsync().Wait();
}
private void before_each()
{
_node = EmbeddedEventStore.Start();
_connection = EmbeddedEventStoreConnection.Create(_node);
_connection.ConnectAsync().Wait();
_sut = new UserRegistrationProcessRepository(_connection, new EventSerializer());
}
private void before_each()
{
_node = EmbeddedEventStore.Start();
_connection = EmbeddedEventStoreConnection.Create(_node);
_connection.ConnectAsync().Wait();
_sut = new UserByEmailIndex(_connection, new EventSerializer());
}
public static void SetupNode()
{
node = CreateInMemoryEventStoreNode();
if (connection == null)
{
connection = EmbeddedEventStoreConnection.Create(node);
connection.ConnectAsync().Wait();
}
}
protected override void InitRepository()
{
_eventStore = new EmbeddedEventStore(11113, 12113);
_eventStore.Start();
_connection = EmbeddedEventStoreConnection.Create(_eventStore.Node);
_connection.ConnectAsync().Wait();
RepoUnderTest = new EventStoreAggregateRepository(_connection);
}
static IEventStoreConnection CreateInMemoryEventStoreConnection()
{
var node = EmbeddedVNodeBuilder.AsSingleNode().OnDefaultEndpoints().RunInMemory().Build();
node.StartAndWaitUntilReady().Wait();
var connection = EmbeddedEventStoreConnection.Create(node);
connection.ConnectAsync().Wait();
return(connection);
}
public async Task Append(string stream, string type, byte[] events)
{
using (var cn = EmbeddedEventStoreConnection.Create(_node))
{
cn.ConnectAsync().Wait();
await cn.AppendToStreamAsync(stream, ExpectedVersion.Any,
new EventData(Guid.NewGuid(), type, true,
events, null));
}
}
public async Task SetUp()
{
var nodeBuilder = EmbeddedVNodeBuilder.AsSingleNode().RunInMemory().OnDefaultEndpoints();
var node = nodeBuilder.Build();
await node.StartAsync(true);
var connection = EmbeddedEventStoreConnection.Create(node);
await connection.ConnectAsync();
EventStoreConnection = connection;
}
public async Task What_happens_when_you_get_metadata_on_stream_that_does_not_exist()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
string streamId = "does-not-exist";
var metadataResult = await connection.GetStreamMetadataAsync(streamId);
metadataResult.IsStreamDeleted.ShouldBe(false);
}
}
public EmbeddedEventStoreFixture()
{
_node = EmbeddedVNodeBuilder
.AsSingleNode()
.OnDefaultEndpoints()
.RunInMemory()
.DisableDnsDiscovery()
.DisableHTTPCaching()
//.DisableScavengeMerging()
.DoNotVerifyDbHashes()
.Build();
_node.StartAndWaitUntilReady().Wait();
Connection = EmbeddedEventStoreConnection.Create(_node);
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory();
var nodeBuilder = EmbeddedVNodeBuilder
.AsSingleNode()
.OnDefaultEndpoints()
.RunInMemory();
var node = nodeBuilder.Build();
node.StartAndWaitUntilReady().Wait();
var testConnection = EmbeddedEventStoreConnection.Create(node);
Plugins.Add(new MetadataFeature());
Plugins.Add(new EventStoreFeature(testConnection, typeof(TestAppHost).Assembly));
}
private static async Task CreateSubscriptionGroups(ClusterVNode clusterVNode)
{
var connectionSettings = PersistentSubscriptionSettings.Create().StartFromCurrent().PreferRoundRobin().Build();
var connection = EmbeddedEventStoreConnection.Create(clusterVNode);
await connection.CreatePersistentSubscriptionAsync(
StaticData.PersistentStreamOne,
StaticData.GroupIdOne,
connectionSettings,
StaticData.EventStoreUserCredentials);
await connection.CreatePersistentSubscriptionAsync(
StaticData.PersistentStreamOne,
StaticData.GroupIdTwo,
connectionSettings,
StaticData.EventStoreUserCredentials);
}
public async Task Read_empty_stream()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
await connection.AppendToStreamAsync("stream-1", ExpectedVersion.NoStream);
var streamEventsSlice = await connection.ReadStreamEventsForwardAsync("stream-1", 0, 2, true);
_testOutputHelper.WriteLine($"From Event Number {streamEventsSlice.FromEventNumber}");
_testOutputHelper.WriteLine($"Next Event Number {streamEventsSlice.NextEventNumber}");
_testOutputHelper.WriteLine($"Last Event Number {streamEventsSlice.LastEventNumber}");
_testOutputHelper.WriteLine($"Events Length {streamEventsSlice.Events.Length}");
//_testOutputHelper.WriteLine($"Events Length {allEventsSlice.Events[0].Event.EventType}");
}
}
public async Task Read_all_forwards()
{
await _node.StartAndWaitUntilInitialized();
using (var connection = EmbeddedEventStoreConnection.Create(_node, _connectionSettingsBuilder))
{
var eventData = new EventData(Guid.NewGuid(), "type", false, null, null);
await connection.AppendToStreamAsync("stream-1", ExpectedVersion.NoStream, eventData);
var allEventsSlice = await connection.ReadAllEventsForwardAsync(Position.End, 1, true);
_testOutputHelper.WriteLine($"FromPosition {allEventsSlice.FromPosition}");
_testOutputHelper.WriteLine($"Next Position {allEventsSlice.NextPosition}");
_testOutputHelper.WriteLine($"Events Length {allEventsSlice.Events.Length}");
//_testOutputHelper.WriteLine($"Events Length {allEventsSlice.Events[0].Event.EventType}");
}
}
private void before_each()
{
var embeddedNode = EmbeddedEventStore.Start();
var embeddedConnection = EmbeddedEventStoreConnection.Create(embeddedNode);
embeddedConnection.ConnectAsync().Wait();
var eventSerializerStub = new EventSerializerStub();
var eventHandlerMock = new EventHandlerMock();
var sut = new EventStoreSubscriptionStarter(new EventSerializerStub(), eventHandlerMock);
_node = embeddedNode;
_connection = embeddedConnection;
_serializer = eventSerializerStub;
_eventHandler = eventHandlerMock;
_sut = sut;
}
