public async Task AddIdentifierToPerson_Success()
{
//Arrange
var resultGuid = Guid.NewGuid();
var testModel = new IdentifierModel {
Value = "test",
PersonId = Guid.NewGuid()
};
var identifierRepository = new Mock <IIdentifiersRepository>();
identifierRepository.Setup(x => x.Add(testModel)).Returns(Task.FromResult(resultGuid));
var personsRepository = new Mock <IPersonsRepository>();
personsRepository.Setup(x => x.Get(testModel.PersonId)).Returns(Task.FromResult(new PersonModel()));
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.SetupGet(x => x.IdentifiersRepository).Returns(identifierRepository.Object);
unitOfWork.SetupGet(x => x.PersonsRepository).Returns(personsRepository.Object);
var dependencyResolver = new Mock <IDependencyResolver>();
dependencyResolver.Setup(x => x.Resolve <IUnitOfWork>()).Returns(unitOfWork.Object);
var identifierService = new IdentifierService(dependencyResolver.Object);
//Act
var id = await identifierService.AddIdentifierToPerson(testModel);
//Assert
Assert.Equal(resultGuid, id);
}
private NodeProperty(MathIdentifier id, Type valueType, Type ownerType, IdentifierService <MathIdentifier> service,
NodeEvent dirtiedEvent, NodeEvent changedEvent)
: base(id, valueType, ownerType, service)
{
_dirtiedEvent = dirtiedEvent;
_changedEvent = changedEvent;
}
public async Task AddIdentifierToPerson_NotFoundPerson()
{
//Arrange
var resultGuid = Guid.NewGuid();
var testModel = new IdentifierModel {
Value = "test",
PersonId = Guid.NewGuid()
};
var identifierRepository = new Mock <IIdentifiersRepository>();
identifierRepository.Setup(x => x.Add(testModel)).Returns(Task.FromResult(resultGuid));
var personsRepository = new Mock <IPersonsRepository>();
personsRepository.Setup(x => x.Get(testModel.PersonId)).Throws(new PersonNotFoundException());
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.SetupGet(x => x.IdentifiersRepository).Returns(identifierRepository.Object);
unitOfWork.SetupGet(x => x.PersonsRepository).Returns(personsRepository.Object);
var dependencyResolver = new Mock <IDependencyResolver>();
dependencyResolver.Setup(x => x.Resolve <IUnitOfWork>()).Returns(unitOfWork.Object);
var identifierService = new IdentifierService(dependencyResolver.Object);
//Act and Assert
await Assert.ThrowsAsync <PersonNotFoundException>(() => identifierService.AddIdentifierToPerson(testModel));
}
public TriggerableAspect(TIdentifier friendly, Type ownerType, IdentifierService <TIdentifier> service)
: base(friendly, service)
{
_ownerType = ownerType;
_eventFlagTriggers = new TriggerableTriggers <TIdentifier, TEvent, TFlag, TFlag, TProperty>();
_eventPropertyTriggers = new TriggerableTriggers <TIdentifier, TEvent, TProperty, TFlag, TProperty>();
}
public Identifier(TFriendlyIdentifier friendly, IdentifierService <TFriendlyIdentifier> owner)
{
_friendly = friendly;
_id = Guid.NewGuid();
if (owner != null)
{
owner.RegisterIdentifier(this); // should fail if friendly already exists -> construction fails
}
}
private NodeFlag(MathIdentifier id, Type ownerType, IdentifierService <MathIdentifier> service, FlagKind kind,
NodeEvent dirtiedEvent, NodeEvent changedEvent, NodeEvent enabledEvent, NodeEvent noLongerEnabledEvent)
: base(id, ownerType, service)
{
_kind = kind;
_dirtiedEvent = dirtiedEvent;
_changedEvent = changedEvent;
_enabledEvent = enabledEvent;
_noLongerEnabledEvent = noLongerEnabledEvent;
}
public void IdentifierServiceShouldReturnProperCodeForNewlyCreatedFactoryAndService()
{
var dbContextOptions = new DbContextOptionsBuilder <IdentifierGeneratorDbContext>()
.UseInMemoryDatabase($"IdentifierDb-{Guid.NewGuid().ToString()}")
.Options;
using (var dbContext = new IdentifierGeneratorDbContext(dbContextOptions))
{
var identifierRepository = new IdentifierRepository(dbContext);
var identifierService = new IdentifierService(identifierRepository);
var code = identifierService.GenerateCodeFor("F001", "C001");
Assert.Equal("C001-F001-1", code);
}
}
public async Task DeleteIdentifier_Fail()
{
//Arrange
var deleteGuid = Guid.NewGuid();
var identifierRepository = new Mock <IIdentifiersRepository>();
identifierRepository.Setup(x => x.Delete(deleteGuid)).Returns(Task.FromResult(0));
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.SetupGet(x => x.IdentifiersRepository).Returns(identifierRepository.Object);
unitOfWork.Setup(x => x.SaveChangesAsync()).Throws(new Exception());
var dependencyResolver = new Mock <IDependencyResolver>();
dependencyResolver.Setup(x => x.Resolve <IUnitOfWork>()).Returns(unitOfWork.Object);
var identifierService = new IdentifierService(dependencyResolver.Object);
//Act
var result = await identifierService.DeleteIdentifier(deleteGuid);
//Assert
Assert.Equal(false, result);
}
public EventAspect(TFriendlyIdentifier friendly, Type handlerType, Type ownerType, IdentifierService <TFriendlyIdentifier> service)
: base(friendly, service)
{
_handlerType = handlerType;
_ownerType = ownerType;
}
public PropertyAspect(TIdentifier friendly, Type valueType, Type ownerType, IdentifierService <TIdentifier> service)
: base(friendly, ownerType, service)
{
_valueType = valueType;
}
public void SetUp()
{
_identifier = new IdentifierService();
}
public FlagAspect(TIdentifier friendly, Type ownerType, IdentifierService <TIdentifier> service)
: base(friendly, ownerType, service)
{
}
private NodeEvent(MathIdentifier id, Type handlerType, Type ownerType, IdentifierService <MathIdentifier> service)
: base(id, handlerType, ownerType, service)
{
}
