public void GetIRepositoryFileText_passed_normal_product_entity_creates_expected_text() { var classNamespace = "Application.Interfaces.Product"; var entity = new FakeEntity().Generate(); entity.PrimaryKeyProperty.Type = "int"; entity.Name = "Product"; entity.Plural = "Products"; var fileText = RepositoryBuilder.GetIRepositoryFileText(classNamespace, entity); var expectedText = @"namespace Application.Interfaces.Product { using System; using Application.Dtos.Product; using Application.Wrappers; using System.Threading.Tasks; using Domain.Entities; public interface IProductRepository { Task<PagedList<Product>> GetProductsAsync(ProductParametersDto ProductParameters); Task<Product> GetProductAsync(int ProductId); Product GetProduct(int ProductId); Task AddProduct(Product product); void DeleteProduct(Product product); void UpdateProduct(Product product); bool Save(); Task<bool> SaveAsync(); } }"; fileText.Should().Be(expectedText); }
public void BatchCommands_works_with_incomplete_updates_for_shared_table_no_leaf_dependent(EntityState state) { var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>(); var stateManager = currentDbContext.GetDependencies().StateManager; var first = new FakeEntity { Id = 42 }; var firstEntry = stateManager.GetOrCreateEntry(first); firstEntry.SetEntityState(state); var second = new DerivedRelatedFakeEntity { Id = 42 }; var secondEntry = stateManager.GetOrCreateEntry(second); secondEntry.SetEntityState(state); var modelData = new UpdateAdapter(stateManager); var batches = CreateBatches(new[] { firstEntry, secondEntry }, modelData, sensitiveLogging: false); Assert.Single(batches); }
public void TryRemove_ShouldDoNothing_WhenEntityIsGiven_AndTapThrowsException(bool expected) { // Arrange var person = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(u => u.TryRemove(person)) .Returns(expected); _mockTap .Setup(u => u.Remove(person)) .Throws(new InvalidOperationException()); var subject = new RepositoryTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object); // Act var result = subject.TryRemove(person); // Assert result.Should().Be(expected); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public void TestInvokeSaveMethodCorrectly(int fakeEntityId, string fakeEntityName, bool useAsyncMethod) { FakeEntity entityExpected = null; SetupFakeRepositorySaveMethod(fe => { var isNew = fe.Id == 0; if (isNew) { entityExpected = CreateTestFakeEntity(null, fe.Name); fe.Id = entityExpected.Id; } else { entityExpected = CreateTestFakeEntity(fe.Id, fe.Name); } }, useAsyncMethod); var entity = CreateTestFakeEntity(fakeEntityId, fakeEntityName); if (useAsyncMethod) { fakeRepository.SaveAsync(entity).GetAwaiter().GetResult(); } else { fakeRepository.Save(entity); } AssertExpectedObject(entityExpected, entity); }
public void BatchCommands_creates_valid_batch_for_shared_table_added_entities() { var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>(); var stateManager = currentDbContext.GetDependencies().StateManager; var first = new FakeEntity { Id = 42, Value = "Test" }; var firstEntry = stateManager.GetOrCreateEntry(first); firstEntry.SetEntityState(EntityState.Added); var second = new RelatedFakeEntity { Id = 42 }; var secondEntry = stateManager.GetOrCreateEntry(second); secondEntry.SetEntityState(EntityState.Added); var modelData = new UpdateAdapter(stateManager); var commandBatches = CreateBatches(new[] { firstEntry, secondEntry }, modelData); Assert.Single(commandBatches); Assert.Equal(1, commandBatches.First().ModificationCommands.Count); var command = commandBatches.First().ModificationCommands.Single(); Assert.Equal(EntityState.Added, command.EntityState); Assert.Equal(4, command.ColumnModifications.Count); var columnMod = command.ColumnModifications[0]; Assert.Equal(nameof(FakeEntity.Id), columnMod.ColumnName); Assert.Equal(first.Id, columnMod.Value); Assert.Equal(first.Id, columnMod.OriginalValue); Assert.False(columnMod.IsCondition); Assert.True(columnMod.IsKey); Assert.False(columnMod.IsRead); Assert.True(columnMod.IsWrite); columnMod = command.ColumnModifications[1]; Assert.Equal(nameof(FakeEntity.RelatedId), columnMod.ColumnName); Assert.Equal(first.RelatedId, columnMod.Value); Assert.Equal(first.RelatedId, columnMod.OriginalValue); Assert.False(columnMod.IsCondition); Assert.False(columnMod.IsKey); Assert.False(columnMod.IsRead); Assert.True(columnMod.IsWrite); columnMod = command.ColumnModifications[2]; Assert.Equal(nameof(FakeEntity.Value), columnMod.ColumnName); Assert.Equal(first.Value, columnMod.Value); Assert.Equal(first.Value, columnMod.OriginalValue); Assert.False(columnMod.IsCondition); Assert.False(columnMod.IsKey); Assert.False(columnMod.IsRead); Assert.True(columnMod.IsWrite); }
public async Task RemoveAsync_ShouldCallInner_WhenEntityIsGiven(bool handlerReturnValue) { // Arrange var entity = new FakeEntity <int> { Id = 5 }; InvalidOperationException actualException = null; _mockInner .Setup(i => i.RemoveAsync(entity)) .Returns(TaskHelpers.CompletedTask); var subject = new AsyncCommandServiceExceptionHandler <FakeEntity <int>, int, InvalidOperationException>(_mockInner.Object, ex => { actualException = ex; return(handlerReturnValue); }); // Act await subject.RemoveAsync(entity).ConfigureAwait(false); // Assert actualException.Should().BeNull(); _mockInner.VerifyAll(); }
public async void Add_ModifiedViaNewInstance_ShouldUpdateOriginal() { // Arrange string oldValue = "Old Value"; string newValue = "New Value"; Guid entityId = Guid.NewGuid(); IRepositoryWithGuidKey <FakeEntity> repository = new MemoryRepository <FakeEntity>(); FakeEntity originalEntity = new FakeEntity { EntityId = entityId, Value = oldValue }; FakeEntity modifiedEntity = new FakeEntity { EntityId = entityId, Value = newValue }; // Act bool result = await repository.SaveAsync(originalEntity); result = result && await repository.SaveAsync(modifiedEntity); // Assert Assert.True(result); Assert.NotSame(originalEntity, modifiedEntity); Assert.Equal(originalEntity.Value, modifiedEntity.Value); }
public async Task TryRemoveAsync_ShouldCallInner_AndReturnResult_WhenEntityIsGiven(bool handlerReturnValue) { // Arrange var entity = new FakeEntity <int> { Id = 5 }; var expectedResult = true; InvalidOperationException actualException = null; _mockInner .Setup(i => i.TryRemoveAsync(entity)) .ReturnsAsync(expectedResult); var subject = new AsyncCommandServiceExceptionHandler <FakeEntity <int>, int, InvalidOperationException>(_mockInner.Object, ex => { actualException = ex; return(handlerReturnValue); }); // Act var actualResult = await subject.TryRemoveAsync(entity).ConfigureAwait(false); // Assert actualResult.Should().Be(expectedResult); actualException.Should().BeNull(); _mockInner.VerifyAll(); }
public void EntityEqualsNotSameFact() { var entity1 = new FakeEntity(1, "Fact"); var entity2 = new FakeEntity(2, "Facter"); entity1.Equals(entity2).Should().BeFalse(); }
public async Task Read() { // Arrange var entity = new FakeEntity("Name"); var model = new object(); var databaseName = $"{DatabaseNamePrefix}.{nameof(Read)}"; var options = new DbContextOptionsBuilder <FakeContext>() .UseInMemoryDatabase(databaseName) .Options; using (var context = new FakeContext(options)) { context.Add(entity); await context.SaveChangesAsync(); } var keyValues = new object[] { entity.Id }; var mapper = new Mock <IMapper>(); mapper.Setup(x => x.Map <object>(It.Is <FakeEntity>(y => y.Name == entity.Name))).Returns(model); var request = new Mock <ReadRequest <FakeEntity, object> >(new object[] { keyValues }); object read; // Act using (var context = new FakeContext(options)) { var requestHandler = new FakeReadRequestHandler(context, mapper.Object); read = await requestHandler.Handle(request.Object, CancellationToken.None); } // Assert Assert.Equal(model, read); }
public void AddAsync_ShouldInvokeHandler_AndRethrow_WhenInnerThrowsException_AndHandlerReturnsFalse() { // Arrange var entity = new FakeEntity <int> { Id = 5 }; var expectedException = new InvalidOperationException(); InvalidOperationException actualException = null; _mockInner .Setup(i => i.AddAsync(entity)) .ThrowsAsync(expectedException); var subject = new AsyncCommandServiceExceptionHandler <FakeEntity <int>, int, InvalidOperationException>(_mockInner.Object, ex => { actualException = ex; return(false); }); // Act Func <Task> action = async() => await subject.AddAsync(entity).ConfigureAwait(false); // Assert action.Should().Throw <InvalidOperationException>(); actualException.Should().BeSameAs(expectedException); _mockInner.VerifyAll(); }
public async Task TryUpdateAsync_ShouldDoNothing_WhenTapThrowsException() { // Arrange var entity = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; var expectedResult = true; _mockInner .Setup(u => u.TryUpdateAsync(entity)) .ReturnsAsync(expectedResult); _mockTap .Setup(u => u.AddOrUpdateAsync(entity)) .ThrowsAsync(new InvalidOperationException()); var subject = new AsyncCommandServiceTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object); // Act var actualResult = await subject.TryUpdateAsync(entity).ConfigureAwait(false); // Assert actualResult.Should().Be(expectedResult); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public async Task TryRemoveAsync_ShouldInvokeHandler_AndReturnResult_WhenEntityIsGiven_AndInnerThrowsException_AndHandlerReturnsTrue() { // Arrange var entity = new FakeEntity <int> { Id = 5 }; var expectedException = new InvalidOperationException(); InvalidOperationException actualException = null; _mockInner .Setup(i => i.TryRemoveAsync(entity)) .ThrowsAsync(expectedException); var subject = new AsyncCommandServiceExceptionHandler <FakeEntity <int>, int, InvalidOperationException>(_mockInner.Object, ex => { actualException = ex; return(true); }); // Act var actualResult = await subject.TryRemoveAsync(entity).ConfigureAwait(false); // Assert actualResult.Should().BeFalse(); actualException.Should().BeSameAs(expectedException); _mockInner.VerifyAll(); }
public async Task TryRemoveAsync_ShouldCallInner_AndTap_WhenLoggerIsGiven_AndEntityIsGiven(bool expected) { // Arrange var entity = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(r => r.TryRemoveAsync(entity)) .Returns(Task.FromResult(expected)); _mockTap .Setup(r => r.RemoveAsync(entity)) .Returns(TaskHelpers.CompletedTask); var subject = new AsyncCommandServiceTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object, _mockLogger.Object); // Act var actualResult = await subject.TryRemoveAsync(entity).ConfigureAwait(false); // Assert actualResult.Should().Be(expected); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public async Task TryRemoveAsync_ShouldLogException_WhenLoggerIsGiven_AndEntityIsGiven_AndTapThrowsException(bool expected) { // Arrange var entity = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(u => u.TryRemoveAsync(entity)) .Returns(Task.FromResult(expected)); _mockTap .Setup(u => u.RemoveAsync(entity)) .ThrowsAsync(new InvalidOperationException()); _mockLogger.Setup(l => l.Log(LogLevel.Warning, 0, It.IsAny <object>(), It.IsAny <InvalidOperationException>(), It.IsAny <Func <object, Exception, string> >())); var subject = new AsyncCommandServiceTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object, _mockLogger.Object); // Act var actualResult = await subject.TryRemoveAsync(entity).ConfigureAwait(false); // Assert actualResult.Should().Be(expected); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public async Task AddAsync_ShouldLogException_WhenLoggerIsGiven_AndTapThrowsException() { // Arrange var entity = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(u => u.AddAsync(entity)) .Returns(TaskHelpers.CompletedTask); _mockTap .Setup(u => u.AddOrUpdateAsync(entity)) .ThrowsAsync(new InvalidOperationException()); _mockLogger.Setup(l => l.Log(LogLevel.Warning, 0, It.IsAny <object>(), It.IsAny <InvalidOperationException>(), It.IsAny <Func <object, Exception, string> >())); var subject = new AsyncCommandServiceTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object, _mockLogger.Object); // Act await subject.AddAsync(entity).ConfigureAwait(false); // Assert _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public void TryAdd_ShouldDoNothing_WhenTapThrowsException() { // Arrange var person = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(u => u.TryAdd(person)) .Returns(true); _mockTap .Setup(u => u.AddOrUpdate(person)) .Throws(new InvalidOperationException()); var subject = new RepositoryTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object); // Act var result = subject.TryAdd(person); // Assert result.Should().BeTrue(); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public void GetProfileFileText_passed_normal_product_entity_creates_expected_text() { var classNamespace = "Application.Mappings"; var entity = new FakeEntity().Generate(); entity.Name = "Product"; var fileText = ProfileBuilder.GetProfileFileText(classNamespace, entity); var expectedText = @"namespace Application.Mappings { using Application.Dtos.Product; using AutoMapper; using Domain.Entities; public class ProductProfile : Profile { public ProductProfile() { //createmap<to this, from this> CreateMap<Product, ProductDto>() .ReverseMap(); CreateMap<ProductForCreationDto, Product>(); CreateMap<ProductForUpdateDto, Product>() .ReverseMap(); } } }"; fileText.Should().Be(expectedText); }
public void TryAdd_ShouldLogException_WhenLoggerIsGiven_AndTapThrowsException() { // Arrange var person = new FakeEntity <int> { Id = 7, Name = "Tiffany" }; _mockInner .Setup(u => u.TryAdd(person)) .Returns(true); _mockTap .Setup(u => u.AddOrUpdate(person)) .Throws(new InvalidOperationException()); _mockLogger.Setup(l => l.Log(LogLevel.Warning, 0, It.IsAny <object>(), It.IsAny <InvalidOperationException>(), It.IsAny <Func <object, Exception, string> >())); var subject = new RepositoryTap <FakeEntity <int>, int>(_mockInner.Object, _mockTap.Object, _mockLogger.Object); // Act var result = subject.TryAdd(person); // Assert result.Should().BeTrue(); _mockInner.VerifyAll(); _mockTap.VerifyAll(); _mockLogger.VerifyAll(); }
public Task takes_snapshot() { var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test"); // Delayes conflicting events to be resolved later var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_snapstore.Object, _eventstore.Object, _channel.Object, streamGen); var entity = new FakeEntity(); (entity as IEntity <FakeState>).Instantiate(new FakeState()); entity.State.TakeASnapshot = true; return(Task.CompletedTask); //await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary<string, string>()) // .ConfigureAwait(false); //Assert.AreEqual(1, entity.Conflicts); //_stream.Verify(x => x.Add(Moq.It.IsAny<IEvent>(), Moq.It.IsAny<IDictionary<string, string>>()), // Moq.Times.Once); //_stream.Verify(x => x.AddSnapshot(Moq.It.IsAny<IMemento>()), Moq.Times.Once); //_store.Verify(x => x.WriteStream<Entity>(Moq.It.IsAny<Guid>(), Moq.It.IsAny<IEventStream>(), // Moq.It.IsAny<IDictionary<string, string>>()), Moq.Times.Once); }
public void EntityEqualsNotSameTypeFact() { var entity = new FakeEntity(1, "Fact"); var FactObj = new object(); entity.Equals(FactObj).Should().BeFalse(); }
private void ThrowsInvalidOperationExceptionWhenIdChanges( Action <FakeEntity, string> setId, Func <SafeMetadataProvider <FakeEntity>, Func <FakeEntity, EntityIdentifier> > getMethod) { // arrange SafeMetadataProvider <FakeEntity> safeMetadataProvider = this.CreateSafeMetadataProvider(); var entity = new FakeEntity() { SourceSystemEntityId = Guid.NewGuid().ToString("d"), DestinationSystemEntityId = Guid.NewGuid().ToString("d"), Label = Guid.NewGuid().ToString("d") }; Func <FakeEntity, EntityIdentifier> method = getMethod(safeMetadataProvider); InvalidOperationException exceptionThrown = null; // act method(entity); setId(entity, Guid.NewGuid().ToString("d")); try { method(entity); } catch (InvalidOperationException exception) { exceptionThrown = exception; } // assert exceptionThrown.Should().NotBeNull(); }
public void EntityEqualsSameFact() { var entity1 = new FakeEntity(1, "Fact"); var entity2 = new FakeEntity(1, "Fact"); entity1.Equals(entity2).Should().BeTrue(); }
public async Task Create() { // Arrange var entity = new FakeEntity("Name"); var model = new object(); var databaseName = $"{DatabaseNamePrefix}.{nameof(Create)}"; var options = new DbContextOptionsBuilder <FakeContext>() .UseInMemoryDatabase(databaseName) .Options; var mapper = new Mock <IMapper>(); mapper.Setup(x => x.Map <FakeEntity>(model)).Returns(entity); mapper.Setup(x => x.Map <object>(It.Is <FakeEntity>(y => y.Name == entity.Name))).Returns(model); var request = new Mock <CreateRequest <FakeEntity, object> >(model); (object, object[])create; // Act using (var context = new FakeContext(options)) { var requestHandler = new FakeCreateRequestHandler(context, mapper.Object); create = await requestHandler.Handle(request.Object, CancellationToken.None); } // Assert Assert.Equal(model, create.Item1); using (var context = new FakeContext(options)) { Assert.NotNull(await context.Set <FakeEntity>().SingleOrDefaultAsync(x => x.Name == entity.Name)); } }
public async Task BatchCommands_creates_batches_lazily() { var configuration = CreateConfiguration(); var model = CreateSimpleFKModel(); var fakeEntity = new FakeEntity { Id = 42, Value = "Test" }; var stateEntry = new MixedStateEntry( configuration, model.GetEntityType(typeof(FakeEntity)), fakeEntity); await stateEntry.SetEntityStateAsync(EntityState.Added); var relatedStateEntry = new MixedStateEntry( configuration, model.GetEntityType(typeof(RelatedFakeEntity)), new RelatedFakeEntity { Id = 42 }); await relatedStateEntry.SetEntityStateAsync(EntityState.Added); var modificationCommandBatchFactoryMock = new Mock <ModificationCommandBatchFactory>(); var commandBatches = CreateCommandBatchPreparer(modificationCommandBatchFactoryMock.Object).BatchCommands(new[] { relatedStateEntry, stateEntry }); var commandBatchesEnumerator = commandBatches.GetEnumerator(); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(), Times.Once); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(), Times.Exactly(2)); }
public async Task Delete() { // Arrange var entity = new FakeEntity("Name"); var databaseName = $"{DatabaseNamePrefix}.{nameof(Delete)}"; var options = new DbContextOptionsBuilder <FakeContext>() .UseInMemoryDatabase(databaseName) .Options; using (var context = new FakeContext(options)) { context.Add(entity); await context.SaveChangesAsync(); } var keyValues = new object[] { entity.Id }; var request = new Mock <DeleteRequest>(new object[] { keyValues }); // Act using (var context = new FakeContext(options)) { var requestHandler = new FakeDeleteRequestHandler(context); await requestHandler.Handle(request.Object, CancellationToken.None); } // Assert using (var context = new FakeContext(options)) { entity = await context.FindAsync <FakeEntity>(keyValues); Assert.Null(entity); } }
public void ObservableHashSetListSource_GetList_returns_BindingList_attached_to_the_ObservableCollection() { var toRemove = new FakeEntity(); var ols = new ObservableHashSetListSource <FakeEntity> { toRemove, new FakeEntity() }; var bindingList = ((IListSource)ols).GetList(); Assert.Equal(2, bindingList.Count); ols.Add(new FakeEntity()); Assert.Equal(3, bindingList.Count); ols.Remove(toRemove); Assert.Equal(2, bindingList.Count); bindingList.Add(new FakeEntity()); Assert.Equal(3, ols.Count); bindingList.RemoveAt(0); Assert.Equal(2, ols.Count); }
public void TryRemoveAsync_ShouldNotCatchException_WhenEntityIsGiven_AndInnerThrowsException_AndTypeIsWrong(bool handlerReturnValue) { // Arrange var entity = new FakeEntity <int> { Id = 5 }; InvalidOperationException actualException = null; _mockInner .Setup(i => i.TryRemoveAsync(entity)) .ThrowsAsync(new Exception()); var subject = new AsyncCommandServiceExceptionHandler <FakeEntity <int>, int, InvalidOperationException>(_mockInner.Object, ex => { actualException = ex; return(handlerReturnValue); }); // Act Func <Task> action = async() => await subject.TryRemoveAsync(entity).ConfigureAwait(false); // Assert action.Should().Throw <Exception>(); actualException.Should().BeNull(); _mockInner.VerifyAll(); }
public void NewEntity_Id_ReturnsStringStartingWithEntityClassName() { var entity = new FakeEntity(); var className = "FakeEntity"; Assert.IsTrue(entity.Id.StartsWith(className)); }
public void BatchCommands_creates_batches_lazily() { var configuration = CreateContextServices(CreateSimpleFKModel()); var stateManager = configuration.GetRequiredService <IStateManager>(); var fakeEntity = new FakeEntity { Id = 42, Value = "Test" }; var entry = stateManager.GetOrCreateEntry(fakeEntity); entry.SetEntityState(EntityState.Added); var relatedentry = stateManager.GetOrCreateEntry(new RelatedFakeEntity { Id = 42 }); relatedentry.SetEntityState(EntityState.Added); var modificationCommandBatchFactoryMock = new Mock <ModificationCommandBatchFactory>(); var options = new Mock <IDbContextOptions>().Object; var commandBatches = CreateCommandBatchPreparer(modificationCommandBatchFactoryMock.Object).BatchCommands(new[] { relatedentry, entry }, options); var commandBatchesEnumerator = commandBatches.GetEnumerator(); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(options), Times.Once); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(options), Times.Exactly(2)); }
public void can_persist_and_retrieve_an_entities() { var entity = new FakeEntity {Id = Guid.NewGuid()}; theRepository.Update(entity); theRepository.Find<FakeEntity>(entity.Id).ShouldBeTheSameAs(entity); }
public void fetch_is_covariant_contravariant_you_know_what_I_mean() { var repository = EntityRepository.InMemory(); var case1 = new FakeEntity(); repository.Update(case1); repository.Find<FakeEntity>(case1.Id).ShouldBeTheSameAs(case1); }
public save_existing_entity_to_cloud() { _entity = new FakeEntity { RowKey = "rowkey", PartitionKey = "partitionkey" }; _entity.Save(); }
public void With_valid_entity_returns_the_added_entity() { var set = new DbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object); var entity = new FakeEntity(); var retVal = set.Attach(entity); Assert.Same(entity, retVal); }
public void assign_a_guid_if_one_does_not_exist() { var repository = EntityRepository.InMemory(); var @case = new FakeEntity(); @case.Id.ShouldBe(Guid.Empty); repository.Update(@case); @case.Id.ShouldBeOfType<Guid>().ShouldNotBe(Guid.Empty); }
public void it_updates_updated_entity() { var entity = new FakeEntity() {RowKey = "rowkey", PartitionKey = "partitionkey"}; _context.AddEntity(entity); entity.Name = "new name"; _context.UpdateEntity(entity); Assert.Equal(1, _context.CreateQuery<FakeEntity>().Count()); Assert.Equal("new name", _context.CreateQuery<FakeEntity>().First().Name); }
InternalReferenceEntry_gets_current_value_from_RelatedEnd_if_navigation_property_has_been_removed_from_entity_implementation (FakeEntity relatedEntity) { var mockRelatedEnd = Core.Objects.DataClasses.MockHelper.CreateMockEntityReference(relatedEntity); var internalEntry = new InternalReferenceEntry( MockHelper.CreateMockInternalEntityEntry(new FakeEntity(), mockRelatedEnd.Object).Object, FakeWithProps.ReferenceMetadata); var propValue = internalEntry.CurrentValue; Assert.Same(relatedEntity, propValue); }
private void InternalReferenceEntry_sets_current_value_onto_entity_if_property_exists_implementation(bool isDetached) { var entity = new FakeWithProps { Reference = new FakeEntity() }; var internalEntry = new InternalReferenceEntry( MockHelper.CreateMockInternalEntityEntry(entity, isDetached).Object, FakeWithProps.ReferenceMetadata); var relatedEntity = new FakeEntity(); internalEntry.CurrentValue = relatedEntity; Assert.Same(relatedEntity, entity.Reference); }
public void CompareNullEntityReturnFalse() { //Arrange var firstEntity = new FakeEntity { Identity = Guid.NewGuid() }; IEntity secondEntity = null; //Act var equalsResult = firstEntity.Equals(secondEntity); bool equalsOperatorResult = firstEntity == secondEntity; bool notEqualsOperatorResult = firstEntity != secondEntity; //Assert Assert.IsFalse(equalsResult); Assert.IsFalse(equalsOperatorResult); Assert.IsTrue(notEqualsOperatorResult); }
public void CompareTheSameReferenceReturnTrue() { //Arrange IEntity firstEntity, secondEntity; firstEntity = secondEntity = new FakeEntity { Identity = Guid.NewGuid() }; //Act var equalsResult = firstEntity.Equals(secondEntity); bool equalsOperatorResult = firstEntity == secondEntity; bool notEqualsOperatorResult = firstEntity != secondEntity; // Assert Assert.IsTrue(equalsResult); Assert.IsTrue(equalsOperatorResult); Assert.IsFalse(notEqualsOperatorResult); }
public void CanDelete() { _moqUnitOfWork.Expect(x => x.Delete(It.IsAny<FakeEntity>())) .AtMost(1); _moqUnitOfWork.Expect(x => x.Flush()) .AtMost(1); IRepository<FakeEntity> repository = _repositoryFactory.GetRepository<FakeEntity>(); using (IUnitOfWork unitOfWork = UnitOfWorkController.Start(_persistenceManager)) { FakeEntity entity = new FakeEntity(); repository.Delete(entity); unitOfWork.Flush(); } }
public void DiferentIdentityProduceEqualsFalse() { //Arrange var firstEntity = new FakeEntity { Identity = Guid.NewGuid() }; var secondEntity = new FakeEntity { Identity = Guid.NewGuid() }; //Act bool equalsResult = firstEntity.Equals(secondEntity); bool equalsOperatorResult = firstEntity == secondEntity; bool notEqualsOperatorResult = firstEntity != secondEntity; //Assert Assert.IsFalse(equalsResult); Assert.IsFalse(equalsOperatorResult); Assert.IsTrue(notEqualsOperatorResult); }
public void OnUpdateUpdatesEntityFields() { var transaction = new Mock<ITransaction>(); var session = new Mock<ISession>(); session.Setup(s => s.BeginTransaction()).Returns(() => transaction.Object); var context = new CommandContext(session.Object, Username); var entity = new FakeEntity(); entity.LastModifiedBy = entity.CreatedBy = InitialUsername; var command = new FakeUpdateCommand(entity); command.Execute(context); Assert.AreEqual(InitialUsername, entity.CreatedBy); Assert.AreEqual(Username, entity.LastModifiedBy); }
public void update_an_existing_case_should_replace_it() { var repository = EntityRepository.InMemory(); var case1 = new FakeEntity(); var case2 = new FakeEntity(); repository.Update(case1); repository.All<FakeEntity>().Single().ShouldBeTheSameAs(case1); repository.Find<FakeEntity>(case1.Id).ShouldBeTheSameAs(case1); case2.Id = case1.Id; repository.Update(case2); repository.All<FakeEntity>().Single().ShouldBeTheSameAs(case2); repository.Find<FakeEntity>(case1.Id).ShouldBeTheSameAs(case2); }
public void can_run_silverlight_from_embedded() { NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080); var container = new Container(); var settings = RavenDbSettings.InMemory(); //settings.Url = "http://localhost:8080"; settings.UseEmbeddedHttpServer = true; container.Inject(settings); var store = settings.Create(); store.Initialize(); Debug.WriteLine(store.Url); //Process.Start("http://localhost:8080"); var store2 = new DocumentStore { Url = "http://localhost:8080", DefaultDatabase = "Portal" }; store2.Initialize(); var entity1 = new FakeEntity { Id = Guid.NewGuid() }; using (var session = store2.OpenSession()) { session.Store(entity1); session.SaveChanges(); } using (var session2 = store2.OpenSession()) { session2.Query<FakeEntity>() .Customize(x => x.WaitForNonStaleResultsAsOfNow()) .Any().ShouldBeTrue(); } }
InternalReferenceEntry_does_not_set_anything_onto_RelatedEnd_if_navigation_property_has_been_removed_from_entity_when_current_value_and_new_value_are_same () { var relatedEntity = new FakeEntity(); InternalReferenceEntry_sets_current_value_onto_RelatedEnd_if_navigation_property_has_been_removed_from_entity_implementation (relatedEntity, relatedEntity); }
public void Generic_DbSet_Add_returns_the_added_entity() { var set = new DbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object); var entity = new FakeEntity(); var retVal = set.Add(entity); Assert.Same(entity, retVal); }
public void BatchCommands_creates_batches_lazily() { var configuration = CreateContextServices(CreateSimpleFKModel()); var stateManager = configuration.GetRequiredService<IStateManager>(); var fakeEntity = new FakeEntity { Id = 42, Value = "Test" }; var entry = stateManager.GetOrCreateEntry(fakeEntity); entry.SetEntityState(EntityState.Added); var relatedentry = stateManager.GetOrCreateEntry(new RelatedFakeEntity { Id = 42 }); relatedentry.SetEntityState(EntityState.Added); var modificationCommandBatchFactoryMock = new Mock<IModificationCommandBatchFactory>(); modificationCommandBatchFactoryMock.Setup(f => f.Create()).Returns(Mock.Of<ModificationCommandBatch>()); var commandBatches = CreateCommandBatchPreparer(modificationCommandBatchFactoryMock.Object).BatchCommands(new[] { relatedentry, entry }); var commandBatchesEnumerator = commandBatches.GetEnumerator(); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify( mcb => mcb.Create(), Times.Once); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify( mcb => mcb.Create(), Times.Exactly(2)); }
public MemberTests() { this.instance = new FakeEntity(); }
public save_single_entity_to_cloud() { _entity = new FakeEntity(); _entity.Save(); }
public void IsNotTransient() { //Arrange IEntity entity; //Act entity = new FakeEntity { Identity = Guid.NewGuid() }; // Assert Assert.IsFalse(entity.IsTransient()); }
public void IsTransient() { //Arrange IEntity entity; //Act entity = new FakeEntity(); // Assert Assert.IsTrue(entity.IsTransient()); }
public FakeUpdateCommand(FakeEntity fakeEntity) { FakeEntity = fakeEntity; }
public FakeCreateCommand(FakeEntity fakeEntity) { FakeEntity = fakeEntity; }
InternalReferenceEntry_sets_current_value_onto_RelatedEnd_if_navigation_property_has_been_removed_from_entity_implementation (FakeEntity currentRelatedEntity, FakeEntity newRelatedEntity) { var mockRelatedEnd = Core.Objects.DataClasses.MockHelper.CreateMockEntityReference(currentRelatedEntity); var internalEntry = new FakeInternalReferenceEntry( MockHelper.CreateMockInternalEntityEntry(new FakeEntity(), mockRelatedEnd.Object).Object, FakeWithProps.ReferenceMetadata); internalEntry.CurrentValue = newRelatedEntity; Assert.Equal(1, internalEntry.SetCount); Assert.Same(newRelatedEntity, internalEntry.ValueSet); }
public void Delegate_to_an_NHibernate_session() { FakeEntity fakeEntity = new FakeEntity(); using (Record) { _mockSession.FlushMode = FlushMode.Commit; Expect.Call(_mockSession.IsOpen).Return(true); Expect.Call(_mockSession.Load<FakeEntity>(Guid.NewGuid())).Return(fakeEntity); LastCall.IgnoreArguments(); } using (Record) { NHibernateSessionAdapter sessionAdapter = new NHibernateSessionAdapter(_mockSession); sessionAdapter.Load<FakeEntity>(new Guid()); } }
private static FakeEntity when_an_entity_is_saved() { var entity = new FakeEntity(); entity.Save(); return entity; }
public async Task BatchCommands_creates_batches_lazily() { var configuration = CreateConfiguration(); var model = CreateSimpleFKModel(); var fakeEntity = new FakeEntity { Id = 42, Value = "Test" }; var stateEntry = new MixedStateEntry( configuration, model.GetEntityType(typeof(FakeEntity)), fakeEntity); await stateEntry.SetEntityStateAsync(EntityState.Added); var relatedStateEntry = new MixedStateEntry( configuration, model.GetEntityType(typeof(RelatedFakeEntity)), new RelatedFakeEntity { Id = 42 }); await relatedStateEntry.SetEntityStateAsync(EntityState.Added); var modificationCommandBatchFactoryMock = new Mock<ModificationCommandBatchFactory>(); var commandBatches = CreateCommandBatchPreparer(modificationCommandBatchFactoryMock.Object).BatchCommands(new[] { relatedStateEntry, stateEntry }); var commandBatchesEnumerator = commandBatches.GetEnumerator(); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(), Times.Once); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify(mcb => mcb.Create(), Times.Exactly(2)); }
public void BatchCommands_creates_batches_lazily() { var configuration = CreateContextServices(CreateSimpleFKModel()); var stateManager = configuration.GetRequiredService<IStateManager>(); var fakeEntity = new FakeEntity { Id = 42, Value = "Test" }; var entry = stateManager.GetOrCreateEntry(fakeEntity); entry.SetEntityState(EntityState.Added); var relatedentry = stateManager.GetOrCreateEntry(new RelatedFakeEntity { Id = 42 }); relatedentry.SetEntityState(EntityState.Added); var modificationCommandBatchFactoryMock = new Mock<IModificationCommandBatchFactory>(); var options = new Mock<IDbContextOptions>().Object; var commandBatches = CreateCommandBatchPreparer(modificationCommandBatchFactoryMock.Object).BatchCommands(new[] { relatedentry, entry }, options); var commandBatchesEnumerator = commandBatches.GetEnumerator(); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify( mcb => mcb.Create(options, It.IsAny<IRelationalMetadataExtensionProvider>()), Times.Once); commandBatchesEnumerator.MoveNext(); modificationCommandBatchFactoryMock.Verify( mcb => mcb.Create(options, It.IsAny<IRelationalMetadataExtensionProvider>()), Times.Exactly(2)); }
public void SetUp() { _entity = new FakeEntity(); }