public async Task MapsTheEntityAndAddsIt(string name, int count)
{
// Arrange
AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);
var repositoryMock = new Mock <IDeletableEntityRepository <Test> >();
var testData = GetTestData();
var saved = false;
repositoryMock.Setup(x => x.AddAsync(It.IsAny <Test>()))
.Callback((Test test) =>
{
testData.Add(test);
});
repositoryMock.Setup(x => x.SaveChangesAsync())
.Callback(() => { saved = true; });
var baseSerivce = new BaseService <Test>(repositoryMock.Object, AutoMapperConfig.MapperInstance);
var testViewModel = new TestViewModel(name, count);
// Act
await baseSerivce.AddAsync(testViewModel);
// Assert
var exists = testData.Any(x => x.Name == name && x.Count == count);
Assert.True(exists);
Assert.True(saved);
}
public void ShouldThrowOnWrongTenantCreate()
{
// Given
// When
Func <Task> action = async() => await _service.AddAsync(_wrongTenantEntity);
// Then
var ex = AsyncAssert.ThrowsAsync <UnauthorizedAccessException>(action).Result;
//Assert.That(ex.InnerExceptions.Any(e => e is UnauthorizedAccessException));
}
public MainViewModel()
{
// should be injected?
users = new UserService();
companies = new CompanyService();
Companies = new ObservableCollection <CompanyProperty>(companies.AsCompanyProperty());
Companies.CollectionChanged += CollectionChanged;
CompanySelectionChanged = new DelegateCommand(() =>
{
if (SelectedCompany != null)
{
if (Users != null)
{
Users.CollectionChanged -= CollectionChanged;
}
var userProperties = users.AsUserProperty(e => e.CompanyId == SelectedCompany.Id);
Users = new ObservableCollection <UserProperty>(userProperties);
Users.CollectionChanged += CollectionChanged;
}
});
CompanyEditEnd = new DelegateCommand(async() =>
{
if (SelectedCompany.Id == 0)
{
var company = await companies.AddAsync(SelectedCompany);
SelectedCompany.Id = company.Id;
}
else
{
await companies.UpdateAsync(SelectedCompany);
}
});
UserEditEnd = new DelegateCommand(async() =>
{
if (SelectedUser.Id == 0)
{
User user = SelectedUser;
user.CompanyId = SelectedCompany.Id;
await users.AddAsync(user);
SelectedUser.Id = user.Id;
}
else
{
await users.UpdateAsync(SelectedUser);
}
});
}
public void Create_Should_Check_Access_And_Generate_New_Guid()
{
// Given
_entity.Id = Guid.Empty;
// When
_service.AddAsync(_entity).Wait();
// Then
_accessChecker.Received().ValidateAccessToEntityAsync(_entity, EntityAction.Create);
_repository.Received().Add(Arg.Is <TenantOwnedEntity>(e => e.Id != Guid.Empty));
_repository.Received().SaveChangesAsync();
}
public async Task ThrowsIfTheInputObjectIsNull()
{
// Arrange
var mapperMock = new Mock <IMapper>();
var repo = new Mock <IDeletableEntityRepository <Test> >();
var baseSerivce = new BaseService <Test>(repo.Object, mapperMock.Object);
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
// Act
await baseSerivce.AddAsync(null);
});
}
public async Task <ActionResult <TResponse> > Post([FromBody] TResponse response)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ret = await BaseService.AddAsync(Mapper1.Map <TEntity>(response));
await Uow.CommitAsync();
var retViewModel = Mapper1.Map <TResponse>(ret);
return(Ok(retViewModel));
//return CreatedAtAction(nameof(Get), new {id = retViewModel.Id}, retViewModel);
}
