public void Update_DbChangedEntityWithRowVersion_ShouldSaveSaga()
        {
            // arrange
            TestSagaDataWithRowVersion newSagaData = AddSagaWithRowVersion();
            string expectedSomeProp1 = Guid.NewGuid().ToString();
            string expectedSomeProp2 = Guid.NewGuid().ToString();

            var persisterRetrievedSagaData = _persister.Get <TestSagaDataWithRowVersion>(newSagaData.Id);

            // simulates another worker updating the saga after "this" saga retrieves it's saga
            using (var dbc = new TestDbContext())
            {
                var fromDb = dbc.TestSagasWithRowVersion.Find(newSagaData.Id);
                fromDb.SomeProp1 = expectedSomeProp1;
                dbc.SaveChanges();
            }

            // act
            persisterRetrievedSagaData.SomeProp2 = expectedSomeProp2;
            _persister.Update(persisterRetrievedSagaData);

            // assert
            using (var dbc = new TestDbContext())
            {
                var fromDb = dbc.TestSagasWithRowVersion.Find(newSagaData.Id);

                fromDb.Id.Should().Be(newSagaData.Id);
                fromDb.OriginalMessageId.Should().Be(newSagaData.OriginalMessageId);
                fromDb.Originator.Should().Be(newSagaData.Originator);

                fromDb.SomeProp1.Should().Be(expectedSomeProp1);
                fromDb.SomeProp2.Should().Be(expectedSomeProp2);
            }
        }
        public void GetByProp_GetsSaga()
        {
            // arrange
            var sagaData = new TestSagaDataWithRowVersion
            {
                Id                = Guid.NewGuid(),
                Originator        = "originator yeah",
                OriginalMessageId = "original message id",
                SomeProp1         = Guid.NewGuid().ToString(),
                SomeProp2         = "somep prop 2"
            };

            using (var dbContext = new TestDbContext())
            {
                dbContext.TestSagasWithRowVersion.Add(sagaData);
                dbContext.SaveChanges();
            }

            // act
            TestSagaDataWithRowVersion retrievedSaga = _persister.Get <TestSagaDataWithRowVersion>(
                "SomeProp1",
                sagaData.SomeProp1);

            // assert
            sagaData.ShouldBeEquivalentTo(retrievedSaga);
        }
        public void Update_DetachedEntity_Throws()
        {
            // arrange
            TestSagaDataWithRowVersion newSagaData = AddSagaWithRowVersion();

            // act
            Action action = () => _persister.Update(newSagaData);

            // assert
            action.ShouldThrow <UpdatingDetachedEntityException>();
        }
        public void Get_Id_GetsSaga()
        {
            // arrange
            TestSagaDataWithRowVersion sagaData = AddSagaWithRowVersion();

            // act
            TestSagaDataWithRowVersion retrievedSaga = _persister.Get <TestSagaDataWithRowVersion>(sagaData.Id);

            // assert
            sagaData.ShouldBeEquivalentTo(retrievedSaga);
        }
        public void GetByProp_NoResults_ReturnsNull()
        {
            // arrange
            using (var dbContext = new TestDbContext())
            {
                dbContext.TestSagasWithRowVersion.RemoveRange(dbContext.TestSagasWithRowVersion);
                dbContext.SaveChanges();
            }

            // act
            TestSagaDataWithRowVersion result = _persister.Get <TestSagaDataWithRowVersion>("SomeProp1", "some value");

            // assert
            result.Should().BeNull();
        }
        private static TestSagaDataWithRowVersion AddSagaWithRowVersion()
        {
            var sagaData = new TestSagaDataWithRowVersion
            {
                Id                = Guid.NewGuid(),
                Originator        = "originator yeah",
                OriginalMessageId = "original message id",
                SomeProp1         = "some prop 1",
                SomeProp2         = "somep prop 2"
            };

            using (var dbContext = new TestDbContext())
            {
                dbContext.TestSagasWithRowVersion.Add(sagaData);
                dbContext.SaveChanges();
            }
            return(sagaData);
        }
        public void Update_ShouldSaveSaga()
        {
            // arrange
            TestSagaDataWithRowVersion sagaData = AddSagaWithRowVersion();

            // act
            var persisterRetrievedSagaData = _persister.Get <TestSagaDataWithRowVersion>(sagaData.Id);

            persisterRetrievedSagaData.SomeProp1 = "some other value";
            _persister.Update(persisterRetrievedSagaData);

            // assert
            using (var dbc = new TestDbContext())
            {
                var fromDb = dbc.TestSagasWithRowVersion.Find(sagaData.Id);
                fromDb.ShouldBeEquivalentTo(persisterRetrievedSagaData);
            }
        }
        public void Complete_ExistingSaga_DeletesSaga()
        {
            // arrange
            TestSagaDataWithRowVersion sagaData = AddSagaWithRowVersion();
            var persisterRetrievedSagaData      = _persister.Get <TestSagaDataWithRowVersion>(sagaData.Id);

            using (var dbc = new TestDbContext())
            {
                dbc.TestSagasWithRowVersion.Find(sagaData.Id).Should().NotBeNull();
            }

            // act
            _persister.Complete(persisterRetrievedSagaData);

            // assert
            using (var dbContext = new TestDbContext())
            {
                dbContext.TestSagasWithRowVersion.Find(sagaData.Id).Should().BeNull();
            }
        }
        public void Save_ShouldSaveSaga()
        {
            // arrange
            var sagaData = new TestSagaDataWithRowVersion
            {
                Id                = Guid.NewGuid(),
                Originator        = "originator yeah",
                OriginalMessageId = "original message id",
                SomeProp1         = "some prop 1",
                SomeProp2         = "somep prop 2"
            };

            // act
            _persister.Save(sagaData);

            // assert
            using (var dbc = new TestDbContext())
            {
                TestSagaDataWithRowVersion fromDb = dbc.TestSagasWithRowVersion.Find(sagaData.Id);
                fromDb.ShouldBeEquivalentTo(sagaData);
            }
        }
        public void Complete_UpdatedSagaWithRowVersion_DeletesSaga()
        {
            // arrange
            TestSagaDataWithRowVersion sagaData = AddSagaWithRowVersion();
            var persisterRetrievedSagaData      = _persister.Get <TestSagaDataWithRowVersion>(sagaData.Id);

            using (var dbc = new TestDbContext())
            {
                TestSagaDataWithRowVersion foundSaga = dbc.TestSagasWithRowVersion.Find(sagaData.Id);
                foundSaga.Should().NotBeNull();

                foundSaga.SomeProp1 = Guid.NewGuid().ToString(); // update prop
                dbc.SaveChanges();
            }

            // act
            _persister.Complete(persisterRetrievedSagaData);

            // assert
            using (var dbContext = new TestDbContext())
            {
                dbContext.TestSagasWithRowVersion.Find(sagaData.Id).Should().BeNull();
            }
        }