public void GetWithUsers_GetOne()
{
SystemDto systemDto = this.GetNewValidDto();
UserDto userDto = GetValidUserDto();
SystemEntity entity = MapperInstance.Map <SystemEntity>(systemDto);
entity.UserSystemLst.Add(new UserSystemEntity
{
SystemId = systemDto.Id,
System = entity,
UserId = userDto.Id,
User = MapperInstance.Map <UserEntity>(userDto)
});
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectIncludingUsers(It.IsAny <string>()))
.Returns(entity);
var serviceMock = this.GetNewService(repositoryMock.Object);
var obtainedDto = serviceMock.Service.GetWithUsers(systemDto.Id);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectIncludingUsers(It.IsAny <string>()), Times.Once);
obtainedDto.Should().NotBeNull();
obtainedDto.Users.Should().NotBeNull();
obtainedDto.Users.Should().HaveCount(1);
obtainedDto.Id.Should().Be(systemDto.Id);
obtainedDto.Users.First().UserId.Should().Be(userDto.Id);
}
public static SystemModel ToModel(this SystemDto systemDto, string cpuId, string topologyId)
{
if (systemDto == null)
{
throw new ArgumentNullException(nameof(systemDto));
}
if (string.IsNullOrWhiteSpace(cpuId))
{
throw new ArgumentException("'cpuId' cannot be empty", nameof(cpuId));
}
if (string.IsNullOrWhiteSpace(topologyId))
{
throw new ArgumentException("'topologyId' cannot be empty", nameof(topologyId));
}
return(new SystemModel
{
Memory = systemDto.Memory.ToModel(),
Os = systemDto.Os.ToModel(),
Timing = systemDto.Timing.ToModel(),
CpuId = cpuId,
TopologyId = topologyId
});
}
public async Task <ActionResult <Answer> > PutSystem(string systemId, SystemDto system)
{
if (systemId != system.Id)
{
throw new Core.Exceptions.WarningException("Diferentes IDs!");
}
await _service.Modify(system, systemId);
return(Ok(Answer.OK_ANSWER));
}
public SystemControllerDeleteTest(WebAppFactoryFixture fixture) :
base(fixture)
{
_systemDto = new SystemDto()
{
Id = null,
Name = "Test.DeleteSystem.Name",
Description = "Test.DeleteSystem.Description"
};
}
public SystemControllerPostTest(WebAppFactoryFixture fixture) :
base(fixture)
{
_systemDto = new SystemDto()
{
Id = "Test.PostSystem.Id",
Name = "Test.PostSystem.Name",
Description = "Test.PostSystem.Description"
};
}
public async void AddAsync_ValidateOk()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
var serviceMock = this.GetNewService(repositoryMock.Object);
await serviceMock.Service.AddAsync(dto);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.InsertAsync(It.IsAny <SystemEntity>()), Times.Once);
}
public async void AddAsync_Null_ThrowException()
{
SystemDto dto = null;
var repositoryMock = this.GetNewEmptyMockedRepository();
var serviceMock = this.GetNewService(repositoryMock.Object);
Func <Task> act = async() => await serviceMock.Service.AddAsync(dto);
await act.Should().ThrowAsync <NullReferenceException>();
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Never);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.InsertAsync(It.IsAny <SystemEntity>()), Times.Never);
}
public async void GetByIdAsync_NotFound_ThrowException()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(null);
var serviceMock = this.GetNewService(repositoryMock.Object);
Func <Task <SystemDto> > getByIdFunc = async() => await serviceMock.Service.GetByIdAsync(new object[] { dto.Id });
await getByIdFunc.Should().ThrowAsync <WarningException>().WithMessage(serviceMock.Service.EntityNotFoundMessage);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
}
public UserServiceSystemTest()
{
_user = this.GetNewValidDto();
_system = this.GetNewValidSystemDto();
_userEntity = MapperInstance.Map <UserEntity>(_user);
_systemEntity = MapperInstance.Map <SystemEntity>(_system);
_userEntityWithSystem = MapperInstance.Map <UserEntity>(_user);
_userEntityWithSystem.UserSystemLst.Add(new UserSystemEntity()
{
SystemId = _system.Id,
UserId = _user.Id,
System = _systemEntity,
User = _userEntity
});
this.SetupRepository();
}
public async void Remove_ValidateOk()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(new ValueTask <SystemEntity>(new SystemEntity()
{
Id = dto.Id
}));
var serviceMock = this.GetNewService(repositoryMock.Object);
await serviceMock.Service.Remove(new object[] { dto.Id });
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.Delete(It.IsAny <SystemEntity>()), Times.Once);
}
public async void GetByIdAsync_GetOne()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(new ValueTask <SystemEntity>(MapperInstance.Map <SystemEntity>(dto)));
var serviceMock = this.GetNewService(repositoryMock.Object);
var obtainedDto = await serviceMock.Service.GetByIdAsync(new object[] { dto.Id });
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
obtainedDto.Should().NotBeNull();
obtainedDto.Id.Should().Be(dto.Id);
obtainedDto.Name.Should().Be(dto.Name);
obtainedDto.Description.Should().Be(dto.Description);
}
public async void AddAsync_IdNull_ThrowException()
{
SystemDto dto = this.GetNewValidDto();
this.ChangeIdToNull(ref dto);
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.InsertAsync(It.Is <SystemEntity>(e => e.Id == null)))
.Throws <ArgumentNullException>();
var serviceMock = this.GetNewService(repositoryMock.Object);
Func <Task> act = async() => await serviceMock.Service.AddAsync(dto);
await act.Should().ThrowAsync <ArgumentNullException>();
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.InsertAsync(It.IsAny <SystemEntity>()), Times.Once);
}
public async void Modify_ValidateOk()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(new ValueTask <SystemEntity>(new SystemEntity()
{
Id = dto.Id
}));
var serviceMock = this.GetNewService(repositoryMock.Object);
await serviceMock.Service.Modify(dto, new object[0]);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
//Entity is updated modifying properties; because first obtain entity from repo.
//serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.Update(It.IsAny<SystemEntity>()), Times.Once);
}
public LoginTests(WebAppFactoryFixture fixture) :
base(fixture)
{
_userDto = new UserDto()
{
Id = null,
Name = "Test.Login.Name",
Description = "Test.Login.Description",
Email = "*****@*****.**",
Pass = "******"
};
_systemDto = new SystemDto()
{
Id = null,
Name = "Test.Login.Name",
Description = "Test.Login.Description"
};
}
public SystemControllerGetTest(WebAppFactoryFixture fixture) :
base(fixture)
{
_systemDto = new SystemDto()
{
Id = null,
Name = "Test.GetSystem.Name",
Description = "Test.GetSystem.Description"
};
_userDto = new UserDto()
{
Id = null,
Name = "Test.GetSystem.Name",
Description = "Test.GetSystem.Description",
Email = "*****@*****.**",
Pass = "******"
};
}
public async void AddAsync_Existent_ThrowWarningException()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(new ValueTask <SystemEntity>(new SystemEntity()
{
Id = dto.Id
}));
var serviceMock = this.GetNewService(repositoryMock.Object);
Func <Task> act = async() => await serviceMock.Service.AddAsync(dto);
await act.Should().ThrowAsync <WarningException>().WithMessage(serviceMock.Service.EntityAlreadyExists);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.InsertAsync(It.IsAny <SystemEntity>()), Times.Never);
}
public async void GetAllAsync_GetOne()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectAllAsync())
.Returns(Task.FromResult(
(IEnumerable <SystemEntity>) new List <SystemEntity> {
MapperInstance.Map <SystemEntity>(dto)
})
)
.Verifiable();
var serviceMock = this.GetNewService(repositoryMock.Object);
var dtos = await serviceMock.Service.GetAllAsync();
serviceMock.MockUnitOfWork.VerifyAll();
serviceMock.MockCache.Verify(mock => mock.GetAsync <IEnumerable <SystemEntity> >(It.IsAny <string>()), Times.Once);
serviceMock.MockCache.Verify(mock => mock.AddAsync(It.IsAny <string>(), It.IsAny <IEnumerable <SystemEntity> >()), Times.Once);
dtos.Should().NotBeNull();
dtos.Should().HaveCount(1);
}
public bool AddSystem(SystemDto dto)
{
return(Unit.SystemRepository.AddSystem(dto.ToModel <ECIT.GIS.Entity.System>()));
}
public bool UpdateSystem(SystemDto dto)
{
return(Unit.SystemRepository.UpdateSystem(dto.ToModel <GIS.Authority.Entity.System>()));
}
protected void ChangeIdToNull(ref SystemDto dto)
{
dto.Id = null;
}
public async Task <ActionResult <Answer <SystemDto> > > PostSystem(SystemDto system)
{
var resSystem = await _service.AddAsync(system);
return(CreatedAtAction(nameof(GetSystem), new { systemId = system.Id }, new Answer <SystemDto>(resSystem)));
}