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();
}
