capture_events_to_a_new_stream_and_fetch_the_events_back_with_stream_id_provided_in_another_database_schema(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            using (var session = store.OpenSession(sessionType))
            {
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = Guid.NewGuid();
                session.Events.StartStream(id, joined, departed);
                session.SaveChanges();

                var streamEvents = session.Events.FetchStream(id);

                Enumerable.Count <IEvent>(streamEvents).ShouldBe(2);
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Data.ShouldBeOfType <MembersJoined>();
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Version.ShouldBe(1);
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Data.ShouldBeOfType <MembersDeparted>();
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Version.ShouldBe(2);

                GenericEnumerableExtensions.Each <IEvent>(streamEvents, x => SpecificationExtensions.ShouldBeGreaterThan(x.Sequence, 0L));
            }
        }
Exemplo n.º 2
0
        public void capture_events_to_an_existing_stream_and_fetch_the_events_back_in_another_database_schema(DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            var id = Guid.NewGuid();
            var started = new QuestStarted();

            using (var session = store.OpenSession(sessionType))
            {
                session.Events.StartStream<Quest>(id, started);
                session.SaveChanges();
            }

            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: append-events
                var joined = new MembersJoined { Members = new string[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                session.Events.Append(id, joined, departed);

                session.SaveChanges();
                // ENDSAMPLE

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(3);
                streamEvents.ElementAt(0).Data.ShouldBeOfType<QuestStarted>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);
                streamEvents.ElementAt(2).Data.ShouldBeOfType<MembersDeparted>();
                streamEvents.ElementAt(2).Version.ShouldBe(3);
            }
        }
Exemplo n.º 3
0
        public IDocumentSession OpenSession(DocumentTracking tracking     = DocumentTracking.IdentityOnly,
                                            IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
        {
            var connection = new ManagedConnection(_connectionFactory, CommandRunnerMode.Transactional, isolationLevel);

            return(openSession(tracking, connection));
        }
Exemplo n.º 4
0
        public void store_and_update_a_document_then_document_should_not_be_updated(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user = new User {
                FirstName = "James", LastName = "Worthy"
            };

            theSession.Store(user);
            theSession.SaveChanges();

            using (var session2 = theStore.OpenSession())
            {
                session2.ShouldNotBeSameAs(theSession);

                var user2 = session2.Load <User>(user.Id);
                user2.FirstName = "Jens";
                user2.LastName  = "Pettersson";

                session2.SaveChanges();
            }

            using (var session3 = theStore.OpenSession())
            {
                var user3 = session3.Load <User>(user.Id);
                user3.FirstName.ShouldBe("James");
                user3.LastName.ShouldBe("Worthy");
            }
        }
Exemplo n.º 5
0
        public Task aggregate_stream_async_has_the_id(DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store   = InitStore(tenancyStyle);
            var questId = Guid.NewGuid();

            return(When.CalledForEachAsync(tenants, async(tenantId, index) =>
            {
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    var parties = await session.Query <QuestParty>().ToListAsync();
                    parties.Count.ShouldBeLessThanOrEqualTo(index);
                }

                //This SaveChanges will fail with missing method (ro collection configured?)
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    var started = new QuestStarted {
                        Name = "Destroy the One Ring"
                    };
                    var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                    session.Events.StartStream <Quest>(questId, started, joined1);
                    await session.SaveChangesAsync();

                    var party = await session.Events.AggregateStreamAsync <QuestParty>(questId);
                    party.Id.ShouldBe(questId);
                }
            }).ShouldThrowIfAsync(
                       (tenancyStyle == TenancyStyle.Single && tenants.Length > 1) || (tenancyStyle == TenancyStyle.Conjoined && tenants.SequenceEqual(SameTenants))
                       ));
        }
Exemplo n.º 6
0
 public IDocumentSession OpenSession(DocumentTracking tracking     = DocumentTracking.IdentityOnly,
                                     IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
 {
     return(openSession(new SessionOptions {
         Tracking = tracking, IsolationLevel = isolationLevel
     }));
 }
        public void persist_a_single_document(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user = new User {
                FirstName = "Magic", LastName = "Johnson"
            };


            theSession.Store(user);

            theSession.SaveChanges();

            using var conn = theStore.Tenancy.Default.Database.CreateConnection();
            conn.Open();

            var reader = conn.CreateCommand($"select data from mt_doc_user where id = '{user.Id}'").ExecuteReader();

            reader.Read();

            var loadedUser = new JsonNetSerializer().FromJson <User>(reader, 0);

            user.ShouldNotBeSameAs(loadedUser);
            loadedUser.FirstName.ShouldBe(user.FirstName);
            loadedUser.LastName.ShouldBe(user.LastName);
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back_with_stream_id_provided(
            DocumentTracking sessionType)
        {
            var store = InitStore();

            using (var session = store.OpenSession(sessionType))
            {
                #region sample_start-stream-with-existing-guid
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = Guid.NewGuid();
                session.Events.StartStream(id, joined, departed);
                session.SaveChanges();
                #endregion sample_start-stream-with-existing-guid

                var streamEvents = session.Events.FetchStream(id);

                Enumerable.Count <IEvent>(streamEvents).ShouldBe(2);
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Data.ShouldBeOfType <MembersJoined>();
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Version.ShouldBe(1);
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Data.ShouldBeOfType <MembersDeparted>();
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Version.ShouldBe(2);
            }
        }
Exemplo n.º 9
0
        public Task capture_events_to_a_new_stream_and_fetch_the_events_back_async(DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store = InitStore(tenancyStyle);

            return(When.CalledForEachAsync(tenants, async(tenantId, index) =>
            {
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    // SAMPLE: start-stream-with-aggregate-type
                    var joined = new MembersJoined {
                        Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                    };
                    var departed = new MembersDeparted {
                        Members = new[] { "Thom" }
                    };

                    var id = session.Events.StartStream <Quest>(joined, departed).Id;
                    await session.SaveChangesAsync();
                    // ENDSAMPLE

                    var streamEvents = await session.Events.FetchStreamAsync(id);

                    streamEvents.Count().ShouldBe(2);
                    streamEvents.ElementAt(0).Data.ShouldBeOfType <MembersJoined>();
                    streamEvents.ElementAt(0).Version.ShouldBe(1);
                    streamEvents.ElementAt(1).Data.ShouldBeOfType <MembersDeparted>();
                    streamEvents.ElementAt(1).Version.ShouldBe(2);

                    streamEvents.Each(e => e.Timestamp.ShouldNotBe(default(DateTimeOffset)));
                }
            }).ShouldSucceedAsync());
        }
        public void query_before_saving(DocumentTracking sessionType)
        {
            var store   = InitStore("event_store");
            var questId = Guid.NewGuid();

            using (var session = store.OpenSession())
            {
                var parties = session.Query <QuestParty>().ToArray();
                parties.Length.ShouldBeLessThanOrEqualTo(0);
            }

            //This SaveChanges will fail with missing method (ro collection configured?)
            using (var session = store.OpenSession())
            {
                var started = new QuestStarted {
                    Name = "Destroy the One Ring"
                };
                var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                session.Events.StartStream <Quest>(questId, started, joined1);
                session.SaveChanges();

                var party = session.Events.AggregateStream <QuestParty>(questId);
                party.Id.ShouldBe(questId);
            }
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back(DocumentTracking sessionType)
        {
            var store = InitStore();

            using (var session = store.OpenSession(sessionType))
            {
                #region sample_start-stream-with-aggregate-type
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = session.Events.StartStream(joined, departed).Id;
                session.SaveChanges();
                #endregion sample_start-stream-with-aggregate-type

                var streamEvents = session.Events.FetchStream(id);

                Enumerable.Count <IEvent>(streamEvents).ShouldBe(2);
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Data.ShouldBeOfType <MembersJoined>();
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Version.ShouldBe(1);
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Data.ShouldBeOfType <MembersDeparted>();
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Version.ShouldBe(2);

                GenericEnumerableExtensions.Each <IEvent>(streamEvents, e => ShouldBeTestExtensions.ShouldNotBe(e.Timestamp, default(DateTimeOffset)));
            }
        }
Exemplo n.º 12
0
        public void persist_a_single_document(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user = new User {
                FirstName = "Magic", LastName = "Johnson"
            };


            theSession.Store(user);

            theSession.SaveChanges();

            using (var runner = theStore.Tenancy.Default.OpenConnection())
            {
                var json = runner.QueryScalar <string>("select data from mt_doc_user where id = '{0}'".ToFormat(user.Id));


                json.ShouldNotBeNull();

                var loadedUser = new JsonNetSerializer().FromJson <User>(new StringReader(json));

                user.ShouldNotBeSameAs(loadedUser);
                loadedUser.FirstName.ShouldBe(user.FirstName);
                loadedUser.LastName.ShouldBe(user.LastName);
            }
        }
        public void capture_immutable_events(DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store = InitStore(tenancyStyle);

            var id = Guid.NewGuid();

            When.CalledForEach(tenants, (tenantId, index) =>
            {
                var immutableEvent = new ImmutableEvent(id, "some-name");

                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    session.Events.Append(id, immutableEvent);
                    session.SaveChanges();
                }

                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    var streamEvents = session.Events.FetchStream(id);

                    streamEvents.Count.ShouldBe(1);
                    var @event = streamEvents.ElementAt(0).Data.ShouldBeOfType <ImmutableEvent>();

                    @event.Id.ShouldBe(id);
                    @event.Name.ShouldBe("some-name");
                }
            }).ShouldThrowIf(
                (tenancyStyle == TenancyStyle.Single && tenants.Length > 1) || (tenancyStyle == TenancyStyle.Conjoined && tenants.SequenceEqual(SameTenants))
                );
        }
Exemplo n.º 14
0
        public void capture_events_to_a_non_existing_stream_and_fetch_the_events_back_in_another_database_schema(
            DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store = InitStore(tenancyStyle);

            When.CalledForEach(tenants, (tenantId, index) =>
            {
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    var joined = new MembersJoined {
                        Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                    };
                    var departed = new MembersDeparted {
                        Members = new[] { "Thom" }
                    };

                    var id = Guid.NewGuid();
                    session.Events.StartStream <Quest>(id, joined);
                    session.Events.Append(id, departed);

                    session.SaveChanges();

                    var streamEvents = session.Events.FetchStream(id);

                    streamEvents.Count().ShouldBe(2);
                    streamEvents.ElementAt(0).Data.ShouldBeOfType <MembersJoined>();
                    streamEvents.ElementAt(0).Version.ShouldBe(1);
                    streamEvents.ElementAt(1).Data.ShouldBeOfType <MembersDeparted>();
                    streamEvents.ElementAt(1).Version.ShouldBe(2);
                }
            }).ShouldSucceed();
        }
Exemplo n.º 15
0
        public void capture_events_to_a_new_stream_and_fetch_the_events_back(DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store = InitStore(tenancyStyle);

            When.CalledForEach(tenants, (tenantId, index) =>
            {
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    session.Logger = new TestOutputMartenLogger(_output);

                    #region sample_start-stream-with-aggregate-type
                    var joined = new MembersJoined {
                        Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                    };
                    var departed = new MembersDeparted {
                        Members = new[] { "Thom" }
                    };

                    var id = session.Events.StartStream <Quest>(joined, departed).Id;
                    session.SaveChanges();
                    #endregion

                    var streamEvents = session.Events.FetchStream(id);

                    streamEvents.Count().ShouldBe(2);
                    streamEvents.ElementAt(0).Data.ShouldBeOfType <MembersJoined>();
                    streamEvents.ElementAt(0).Version.ShouldBe(1);
                    streamEvents.ElementAt(1).Data.ShouldBeOfType <MembersDeparted>();
                    streamEvents.ElementAt(1).Version.ShouldBe(2);

                    streamEvents.Each(e => e.Timestamp.ShouldNotBe(default(DateTimeOffset)));
                }
            }).ShouldSucceed();
        }
Exemplo n.º 16
0
        public void assert_on_max_event_id_on_event_stream_append(
            DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store = InitStore(tenancyStyle);

            var id = Guid.NewGuid();

            When.CalledForEach(tenants, (tenantId, index) =>
            {
                var started = new QuestStarted();

                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    #region sample_append-events-assert-on-eventid
                    session.Events.StartStream <Quest>(id, started);
                    session.SaveChanges();

                    var joined = new MembersJoined {
                        Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                    };
                    var departed = new MembersDeparted {
                        Members = new[] { "Thom" }
                    };

                    // Events are appended into the stream only if the maximum event id for the stream
                    // would be 3 after the append operation.
                    session.Events.Append(id, 3, joined, departed);

                    session.SaveChanges();
                    #endregion
                }
            }).ShouldThrowIf(
                (tenancyStyle == TenancyStyle.Single && tenants.Length > 1) || (tenancyStyle == TenancyStyle.Conjoined && tenants.SequenceEqual(SameTenants))
                );
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back(DocumentTracking sessionType)
        {
            var store = InitStore();


            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: start-stream-with-aggregate-type
                var joined = new MembersJoined { Members = new[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                var id = session.Events.StartStream<Quest>(joined, departed);
                session.SaveChanges();
                // ENDSAMPLE

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType<MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);

                streamEvents.Each(e => e.Timestamp.ShouldNotBe(default(DateTimeOffset)));
            }
        }
        public void live_aggregate_equals_inlined_aggregate_without_hidden_contracts(DocumentTracking sessionType)
        {
            var store   = InitStore("event_store");
            var questId = Guid.NewGuid();

            using (var session = store.OpenSession())
            {
                //Note Id = questId, is we remove it from first message then AggregateStream will return party.Id=default(Guid) that is not equals to Load<QuestParty> result
                var started = new QuestStarted { /*Id = questId,*/
                    Name = "Destroy the One Ring"
                };
                var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                session.Events.StartStream <Quest>(questId, started, joined1);
                session.SaveChanges();
            }

            using (var session = store.OpenSession())
            {
                var liveAggregate    = session.Events.AggregateStream <QuestParty>(questId);
                var inlinedAggregate = session.Load <QuestParty>(questId);
                liveAggregate.Id.ShouldBe(inlinedAggregate.Id);
                inlinedAggregate.ToString().ShouldBe(liveAggregate.ToString());
            }
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back_in_another_database_schema(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            using (var session = store.OpenSession(sessionType))
            {
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = session.Events.StartStream <Quest>(joined, departed);
                session.SaveChanges();

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType <MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType <MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);
            }
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back(DocumentTracking sessionType)
        {
            var store = InitStore();


            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: start-stream-with-aggregate-type
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = session.Events.StartStream <Quest>(joined, departed);
                session.SaveChanges();
                // ENDSAMPLE

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType <MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType <MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);
            }
        }
        public void assert_on_max_event_id_on_event_stream_append(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            var id      = Guid.NewGuid();
            var started = new QuestStarted();

            using (var session = store.OpenSession(sessionType))
            {
                #region sample_append-events-assert-on-eventid
                session.Events.StartStream(id, started);
                session.SaveChanges();

                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                // Events are appended into the stream only if the maximum event id for the stream
                // would be 3 after the append operation.
                session.Events.Append(id, 3, joined, departed);

                session.SaveChanges();
                #endregion sample_append-events-assert-on-eventid
            }
        }
        public void load_by_id_array(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user1 = new User {
                FirstName = "Magic", LastName = "Johnson"
            };
            var user2 = new User {
                FirstName = "James", LastName = "Worthy"
            };
            var user3 = new User {
                FirstName = "Michael", LastName = "Cooper"
            };
            var user4 = new User {
                FirstName = "Mychal", LastName = "Thompson"
            };
            var user5 = new User {
                FirstName = "Kurt", LastName = "Rambis"
            };

            theSession.Store(user1);
            theSession.Store(user2);
            theSession.Store(user3);
            theSession.Store(user4);
            theSession.Store(user5);
            theSession.SaveChanges();

            using (var session = theStore.OpenSession())
            {
                var users = session.LoadMany <User>(user2.Id, user3.Id, user4.Id);
                users.Count().ShouldBe(3);
            }
        }
Exemplo n.º 23
0
        public async Task persist_and_reload_a_document_async_using_buffers(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user = new User {
                FirstName = "James", LastName = "Worthy"
            };

            StoreOptions(_ => { _.UseCharBufferPooling = true; });

            var store = theStore;

            using (var session1 = store.OpenSession())
            {
                session1.Store(user);
                await session1.SaveChangesAsync().ConfigureAwait(false);
            }

            using (var session2 = store.OpenSession())
            {
                var user2 = await session2.LoadAsync <User>(user.Id).ConfigureAwait(false);

                user.ShouldNotBeSameAs(user2);
                user2.FirstName.ShouldBe(user.FirstName);
                user2.LastName.ShouldBe(user.LastName);
            }
        }
Exemplo n.º 24
0
        public void live_aggregate_equals_inlined_aggregate_without_hidden_contracts(DocumentTracking sessionType, TenancyStyle tenancyStyle, string[] tenants)
        {
            var store   = InitStore(tenancyStyle);
            var questId = Guid.NewGuid();

            When.CalledForEach(tenants, (tenantId, index) =>
            {
                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    //Note Id = questId, is we remove it from first message then AggregateStream will return party.Id=default(Guid) that is not equals to Load<QuestParty> result
                    var started = new QuestStarted { /*Id = questId,*/
                        Name = "Destroy the One Ring"
                    };
                    var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                    session.Events.StartStream <Quest>(questId, started, joined1);
                    session.SaveChanges();
                }

                using (var session = store.OpenSession(tenantId, sessionType))
                {
                    var liveAggregate    = session.Events.AggregateStream <QuestParty>(questId);
                    var inlinedAggregate = session.Load <QuestParty>(questId);
                    liveAggregate.Id.ShouldBe(inlinedAggregate.Id);
                    inlinedAggregate.ToString().ShouldBe(liveAggregate.ToString());
                }
            }).ShouldThrowIf(
                (tenancyStyle == TenancyStyle.Single && tenants.Length > 1) || (tenancyStyle == TenancyStyle.Conjoined && tenants.SequenceEqual(SameTenants))
                );
        }
Exemplo n.º 25
0
        public void persist_and_reload_a_document_using_buffers(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var user = new User {
                FirstName = "James", LastName = "Worthy"
            };

            StoreOptions(_ => { _.UseCharBufferPooling = true; });

            using (var session1 = theStore.OpenSession())
            {
                session1.Store(user);
                session1.SaveChanges();
            }

            using (var session2 = theStore.OpenSession())
            {
                var user2 = session2.Load <User>(user.Id);

                user.ShouldNotBeSameAs(user2);
                user2.FirstName.ShouldBe(user.FirstName);
                user2.LastName.ShouldBe(user.LastName);
            }
        }
        public async Task capture_events_to_a_new_stream_and_fetch_the_events_back_async_with_linq(DocumentTracking sessionType)
        {
            var store = InitStore();


            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: start-stream-with-aggregate-type
                var joined = new MembersJoined { Members = new[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                var id = session.Events.StartStream<Quest>(joined, departed);
                await session.SaveChangesAsync();
                // ENDSAMPLE

                var streamEvents = await session.Events.QueryAllRawEvents()
                    .Where(x => x.StreamId == id).OrderBy(x => x.Version).ToListAsync();
                    

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType<MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);

                streamEvents.Each(e => e.Timestamp.ShouldNotBe(default(DateTimeOffset)));
            }
        }
        public void capture_events_to_a_non_existing_stream_and_fetch_the_events_back_in_another_database_schema(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            using (var session = store.OpenSession(sessionType))
            {
                var joined = new MembersJoined {
                    Members = new[] { "Rand", "Matt", "Perrin", "Thom" }
                };
                var departed = new MembersDeparted {
                    Members = new[] { "Thom" }
                };

                var id = Guid.NewGuid();
                session.Events.StartStream(id, joined);
                session.Events.Append(id, departed);

                session.SaveChanges();

                var streamEvents = session.Events.FetchStream(id);

                Enumerable.Count <IEvent>(streamEvents).ShouldBe(2);
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Data.ShouldBeOfType <MembersJoined>();
                Enumerable.ElementAt <IEvent>(streamEvents, 0).Version.ShouldBe(1);
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Data.ShouldBeOfType <MembersDeparted>();
                Enumerable.ElementAt <IEvent>(streamEvents, 1).Version.ShouldBe(2);
            }
        }
 public CompiledQuerySourceBuilder(CompiledQueryPlan plan, StoreOptions storeOptions,
                                   DocumentTracking documentTracking)
 {
     _plan             = plan;
     _storeOptions     = storeOptions;
     _documentTracking = documentTracking;
     _typeName         = documentTracking + plan.QueryType.ToSuffixedTypeName("CompiledQuerySource");
 }
Exemplo n.º 29
0
        public CompiledQueryCodeFile(Type compiledQueryType, DocumentStore store, CompiledQueryPlan plan, DocumentTracking documentTracking)
        {
            _plan = plan ?? throw new ArgumentNullException(nameof(plan));
            _compiledQueryType = compiledQueryType;
            _store             = store;

            _typeName         = documentTracking + compiledQueryType.ToSuffixedTypeName("CompiledQuerySource");
            _documentTracking = documentTracking;
        }
Exemplo n.º 30
0
        public IDocumentSession OpenSession(DocumentTracking tracking = DocumentTracking.IdentityOnly, IsolationLevel isolationLevel = IsolationLevel.ReadUncommitted)
        {
            var map     = createMap(tracking);
            var session = new DocumentSession(_options, Schema, _serializer, new ManagedConnection(_connectionFactory, CommandRunnerMode.Transactional, isolationLevel), _parser, map);

            session.Logger = _logger.StartSession(session);

            return(session);
        }
Exemplo n.º 31
0
        private IDocumentSession openSession(DocumentTracking tracking, ManagedConnection connection)
        {
            var map     = createMap(tracking);
            var session = new DocumentSession(this, _options, Schema, _serializer, connection, _parser, map);

            connection.BeginSession();

            session.Logger = _logger.StartSession(session);

            return(session);
        }
Exemplo n.º 32
0
        private IDocumentSession openSession(DocumentTracking tracking, ManagedConnection connection, IList <IDocumentSessionListener> localListeners)
        {
            var sessionPool = CreateWriterPool();
            var map         = createMap(tracking, sessionPool, localListeners);

            var session = new DocumentSession(this, _options, Schema, _serializer, connection, _parser, map, sessionPool, localListeners);

            connection.BeginSession();

            session.Logger = _logger.StartSession(session);

            return(session);
        }
        public void then_a_document_can_be_added_with_then_specified_id(DocumentTracking tracking)
        {
            DocumentTracking = tracking;

            var id = Guid.NewGuid();

            var notFound = theSession.Load <User>(id);

            var replacement = new User {
                Id = id, FirstName = "Tim", LastName = "Cools"
            };

            theSession.Store(replacement);
        }
        public void capture_events_to_a_new_stream_and_fetch_the_events_back(DocumentTracking sessionType)
        {
            var store = InitStore();

            using (var session = store.OpenSession(sessionType))
            {
                var joined = new MembersJoined { Members = new string[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                var id = session.Events.StartStream<Quest>(joined, departed);
                session.SaveChanges();

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(1).ShouldBeOfType<MembersDeparted>();
            }
        }
        public void live_aggregate_equals_inlined_aggregate_without_hidden_contracts(DocumentTracking sessionType)
        {
            var store = InitStore("event_store");
            var questId = Guid.NewGuid();

            using (var session = store.OpenSession())
            {
                //Note Id = questId, is we remove it from first message then AggregateStream will return party.Id=default(Guid) that is not equals to Load<QuestParty> result
                var started = new QuestStarted { /*Id = questId,*/ Name = "Destroy the One Ring" };
                var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                session.Events.StartStream<Quest>(questId, started, joined1);
                session.SaveChanges();
            }

            using (var session = store.OpenSession())
            {
                var liveAggregate = session.Events.AggregateStream<QuestParty>(questId);
                var inlinedAggregate = session.Load<QuestParty>(questId);
                liveAggregate.Id.ShouldBe(inlinedAggregate.Id);
                inlinedAggregate.ToString().ShouldBe(liveAggregate.ToString());
            }
        }
Exemplo n.º 36
0
        public void capture_events_to_a_new_stream_and_fetch_the_events_back_with_stream_id_provided(DocumentTracking sessionType)
        {
            var store = InitStore();

            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: start-stream-with-existing-guid
                var joined = new MembersJoined { Members = new string[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                var id = Guid.NewGuid();
                session.Events.StartStream<Quest>(id, joined, departed);
                session.SaveChanges();
                // ENDSAMPLE

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType<MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);
            }
        }
        public void open_persisted_stream_in_new_store_with_same_settings(DocumentTracking sessionType)
        {
            var store = InitStore("event_store");
            var questId = Guid.NewGuid();

            using (var session = store.OpenSession())
            {
                //Note "Id = questId" @see live_aggregate_equals_inlined_aggregate...
                var started = new QuestStarted { Id = questId, Name = "Destroy the One Ring" };
                var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                session.Events.StartStream<Quest>(questId, started, joined1);
                session.SaveChanges();
            }

            // events-aggregate-on-the-fly - works with same store
            using (var session = store.OpenSession())
            {
                // questId is the id of the stream
                var party = session.Events.AggregateStream<QuestParty>(questId);

                party.Id.ShouldBe(questId);
                party.ShouldNotBeNull();

                var party_at_version_3 = session.Events
                    .AggregateStream<QuestParty>(questId, 3);

                party_at_version_3.ShouldNotBeNull();

                var party_yesterday = session.Events
                    .AggregateStream<QuestParty>(questId, timestamp: DateTime.UtcNow.AddDays(-1));
                party_yesterday.ShouldNotBeNull();
            }

            using (var session = store.OpenSession())
            {
                var party = session.Load<QuestParty>(questId);
                party.Id.ShouldBe(questId);
            }

            var newStore = InitStore("event_store", false);

            //Inline is working
            using (var session = store.OpenSession())
            {
                var party = session.Load<QuestParty>(questId);
                party.ShouldNotBeNull();
            }
            //GetAll
            using (var session = store.OpenSession())
            {
                var parties = session.Events.QueryRawEventDataOnly<QuestParty>().ToArray();
                foreach (var party in parties)
                {
                    party.ShouldNotBeNull();
                }
            }
            //This AggregateStream fail with NPE
            using (var session = newStore.OpenSession())
            {
                // questId is the id of the stream
                var party = session.Events.AggregateStream<QuestParty>(questId);//Here we get NPE
                party.Id.ShouldBe(questId);

                var party_at_version_3 = session.Events
                    .AggregateStream<QuestParty>(questId, 3);
                party_at_version_3.Id.ShouldBe(questId);

                var party_yesterday = session.Events
                    .AggregateStream<QuestParty>(questId, timestamp: DateTime.UtcNow.AddDays(-1));
                party_yesterday.Id.ShouldBe(questId);
            }
        }
        public void query_before_saving(DocumentTracking sessionType)
        {
            var store = InitStore("event_store");
            var questId = Guid.NewGuid();

            using (var session = store.OpenSession())
            {
                var parties = session.Query<QuestParty>().ToArray();
                parties.Length.ShouldBeLessThanOrEqualTo(0);
            }

            //This SaveChanges will fail with missing method (ro collection configured?)
            using (var session = store.OpenSession())
            {
                var started = new QuestStarted { Name = "Destroy the One Ring" };
                var joined1 = new MembersJoined(1, "Hobbiton", "Frodo", "Merry");

                session.Events.StartStream<Quest>(questId, started, joined1);
                session.SaveChanges();

                var party = session.Events.AggregateStream<QuestParty>(questId);
                party.Id.ShouldBe(questId);
            }
        }
            capture_events_to_a_new_stream_and_fetch_the_events_back_with_stream_id_provided_in_another_database_schema(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            using (var session = store.OpenSession(sessionType))
            {
                var joined = new MembersJoined { Members = new[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                var id = Guid.NewGuid();
                session.Events.StartStream<Quest>(id, joined, departed);
                session.SaveChanges();

                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count().ShouldBe(2);
                streamEvents.ElementAt(0).Data.ShouldBeOfType<MembersJoined>();
                streamEvents.ElementAt(0).Version.ShouldBe(1);
                streamEvents.ElementAt(1).Data.ShouldBeOfType<MembersDeparted>();
                streamEvents.ElementAt(1).Version.ShouldBe(2);

                streamEvents.Each(x => x.Sequence.ShouldBeGreaterThan(0L));
            }
        }
        public void assert_on_max_event_id_on_event_stream_append(
            DocumentTracking sessionType)
        {
            var store = InitStore("event_store");

            var id = Guid.NewGuid();
            var started = new QuestStarted();
            
            using (var session = store.OpenSession(sessionType))
            {
                // SAMPLE: append-events-assert-on-eventid
                session.Events.StartStream<Quest>(id, started);
                session.SaveChanges();

                var joined = new MembersJoined { Members = new[] { "Rand", "Matt", "Perrin", "Thom" } };
                var departed = new MembersDeparted { Members = new[] { "Thom" } };

                // Events are appended into the stream only if the maximum event id for the stream
                // would be 3 after the append operation.
                session.Events.Append(id, 3, joined, departed);

                session.SaveChanges();
                // ENDSAMPLE
            }
        }
        public void capture_immutable_events(DocumentTracking sessionType)
        {
            var store = InitStore();

            var id = Guid.NewGuid();
            var immutableEvent = new ImmutableEvent(id, "some-name");

            using (var session = store.OpenSession(sessionType))
            {
                session.Events.Append(id, immutableEvent);
                session.SaveChanges();
            }

            using (var session = store.OpenSession(sessionType))
            {
                var streamEvents = session.Events.FetchStream(id);

                streamEvents.Count.ShouldBe(1);
                var @event = streamEvents.ElementAt(0).Data.ShouldBeOfType<ImmutableEvent>();

                @event.Id.ShouldBe(id);
                @event.Name.ShouldBe("some-name");
            }
        }