public async void GetByIdAsync_ReturnOneElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.GetByIdAsync <Guid, TestEntity>(It.IsAny <Guid>())).ReturnsAsync(_entity);
var service = new CrudService <Guid, TestEntity>(repositoryMock.Object);
var result = await service.GetByIdAsync(Guid.Empty);
Assert.Equal(result.Id, _entity.Id);
repositoryMock.Verify(_ => _.GetByIdAsync <Guid, TestEntity>(It.IsAny <Guid>()), Times.Once);
}
public CrewPage()
{
this.InitializeComponent();
Crews = new ObservableCollection <CrewDTO>();
Stewardesses = new ObservableCollection <StewardessDTO>();
Pilots = new ObservableCollection <PilotDTO>();
PilotService = new CrudService <PilotDTO>("pilot");
StewardessService = new CrudService <StewardessDTO>("stewardess");
Service = new CrudService <CrewDTO>("crew");
selectedIds = new ObservableCollection <int>();
isCreate = false;
}
public async void GetAllAsync_ReturnElements()
{
var repositoryMock = new Mock <CrudRepository>();
repositoryMock.Setup(_ => _.GetAllAsync <TestEntity>()).ReturnsAsync(_entities);
var service = new CrudService <TestDto, TestEntity>(repositoryMock.Object, _mapper);
var result = await service.GetAllAsync();
Assert.Equal(_entities.Count, result.Count());
repositoryMock.Verify(_ => _.GetAllAsync <TestEntity>(), Times.Once);
}
public async Task Update()
{
// Arrange
var obj = new UserEntity();
// Act
var service = new CrudService <UserEntity>(_logger.Object, _crudRepository.Object);
var result = await Record.ExceptionAsync(() => service.Update(obj));
// Assert
Assert.Null(result);
}
public void GetAll_ReturnElements()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.GetAllAsync <Guid, TestEntity>()).ReturnsAsync(_entities);
var service = new CrudService <Guid, TestEntity>(repositoryMock.Object);
var result = service.GetAll();
Assert.Equal(result.Count(), _entities.Count());
repositoryMock.Verify(_ => _.GetAllAsync <Guid, TestEntity>(), Times.Once);
}
public async void UpdateAsync_ReturnsUpdatedElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.GetByIdAsync <TestEntity>(_entity.Id)).ReturnsAsync(_entity);
var service = new CrudService <TestEntity>(repositoryMock.Object);
var result = await service.UpdateAsync(_entity.Id, _entity);
Assert.Equal(_entity.Id, result.Id);
repositoryMock.Verify(_ => _.GetByIdAsync <TestEntity>(It.IsAny <Guid>()), Times.Once());
repositoryMock.Verify(_ => _.SaveChanges(), Times.Once);
}
public async Task GetById()
{
// Arrange
_crudRepository.Setup(x => x.GetById(1))
.Returns(Task.FromResult(new UserEntity()));
// Act
var service = new CrudService <UserEntity>(_logger.Object, _crudRepository.Object);
var result = await service.GetById(1);
// Assert
Assert.NotNull(result);
}
//
static public CrudService GetService(IIdentity user, String serviceName)
{
LoginResponse login = (LoginResponse)user;
if (login.servicesNames.Contains(serviceName) == false)
{
throw new Exception("Unauthorized service Access");
}
CrudService service = RequestFilter.mapService[serviceName];
return(service);
}
public async void CreateAsync_ReturnsCreatedElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.CreateAsync(It.IsAny <TestEntity>())).ReturnsAsync(_entity);
var service = new CrudService <TestDto, TestEntity>(repositoryMock.Object, _mapper);
var result = await service.CreateAsync(_dto);
Assert.Equal(_entity.Id, result.Id);
repositoryMock.Verify(_ => _.CreateAsync(It.IsAny <TestEntity>()), Times.Once);
repositoryMock.Verify(_ => _.SaveChanges(), Times.Once);
}
public async Task Select()
{
// Arrange
_crudRepository.Setup(x => x.Select(a => a.Id == 1))
.Returns(Task.FromResult <IEnumerable <UserEntity> >(new List <UserEntity>()));
// Act
var service = new CrudService <UserEntity>(_logger.Object, _crudRepository.Object);
var result = await service.Select(a => a.Id == 1);
// Assert
Assert.NotNull(result);
}
public void Create_ReturnsCreatedElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.Create(It.IsAny <TestEntity>())).Returns(_entity);
var service = new CrudService <TestEntity>(repositoryMock.Object);
var result = service.Create(_entity);
Assert.Equal(_entity.Id, result.Id);
repositoryMock.Verify(_ => _.Create(It.IsAny <TestEntity>()), Times.Once);
repositoryMock.Verify(_ => _.SaveChanges(), Times.Once);
}
public void Update_ReturnsUpdatedElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.GetById <TestEntity>(_entity.Id)).Returns(_entity);
var service = new CrudService <TestDto, TestEntity>(repositoryMock.Object, _mapper);
var result = service.Update(_entity.Id, _dto);
Assert.Equal(_entity.Id, result.Id);
repositoryMock.Verify(_ => _.GetById <TestEntity>(It.IsAny <Guid>()), Times.Once());
repositoryMock.Verify(_ => _.SaveChanges(), Times.Once);
}
// private
static private DbUtils.QueryMap ParseQueryParameters(LoginResponse login, String serviceName, IQueryCollection queryParameters)
{
CrudService service = RequestFilter.GetService(login, serviceName);
DbUtils.QueryMap queryFields = DbUtils.QueryMap.Create();
JObject serviceFields = JObject.Parse(service.Fields);
foreach (var item in serviceFields)
{
JToken field = item.Value;
if (field.Value <Boolean> ("primaryKey") == true)
{
StringValues values = queryParameters [item.Key];
if (values.Count > 0)
{
String type = field.Value <String> ("type");
if (type == null || type.Equals("s"))
{
queryFields.Add(item.Key, values.First());
}
else if (type.Equals("n") || type.Equals("i"))
{
queryFields.Add(item.Key, int.Parse(values.First()));
}
else if (type.Equals("b"))
{
queryFields.Add(item.Key, Boolean.Parse(values.First()));
}
}
}
}
// se não for admin, limita os resultados para as crudGroup vinculadas a empresa do usuário
int?crudGroupOwner = login.user.CrudGroupOwner;
if (crudGroupOwner != 1)
{
if (serviceFields.ContainsKey("crudGroupOwner"))
{
queryFields["crudGroupOwner"] = crudGroupOwner;
}
else if (serviceFields.ContainsKey("crudGroup"))
{
queryFields["crudGroup"] = login.groups;
}
}
return(queryFields);
}
public void Delete_ReturnsDeletedElement()
{
var repositoryMock = new Mock <ICrudRepository>();
repositoryMock.Setup(_ => _.GetByIdAsync <Guid, TestEntity>(_entity.Id)).ReturnsAsync(_entity);
var service = new CrudService <Guid, TestEntity>(repositoryMock.Object);
var result = service.Delete(_entity.Id);
Assert.Equal(_entity.Id, result.Id);
repositoryMock.Verify(_ => _.GetByIdAsync <Guid, TestEntity>(It.IsAny <Guid>()), Times.Once());
repositoryMock.Verify(_ => _.DeleteAsync <Guid, TestEntity>(It.IsAny <Guid>()), Times.Once);
repositoryMock.Verify(_ => _.SaveChangesAsync(), Times.Once);
}
public async Task Get_ResturnsNull_WhenIdNotExists()
{
//Arrage
var context = new Mock <DbContext>();
context.Setup(x => x.Set <Entity>().FindAsync(It.IsAny <CancellationToken>(), It.IsAny <int>())).ReturnsAsync((Entity)null);
var service = new CrudService <Entity>(context.Object);
//Act
var result = await service.ReadAsync(default(int));
//Assert
Assert.Null(result);
}
public async Task Get_ResturnsEntity_WhenIdExists()
{
//Arrage
var context = new Mock <DbContext>();
var expected = new Mock <Entity>().Object;
context.Setup(x => x.Set <Entity>().FindAsync(It.IsAny <int>())).ReturnsAsync(expected);
var service = new CrudService <Entity>(context.Object);
//Act
var result = await service.ReadAsync(default(int));
//Assert
Assert.Equal(expected, result);
}
static void Main(string[] args)
{
CrudService importService = new CrudService();
var datas = importService.loadData();
//Console.Write(datas);
Console.WriteLine("空氣品質指標(AQI)");
Console.WriteLine("輸入0顯示完整資訊，輸入1顯示以空汙指標物分類，輸入2顯示以狀態分類");
Console.Write("輸入3以輸出至LocalDB，輸入d刪除資料，輸入4以查詢資料:");
var input = Console.ReadLine();
//Console.Write(input);
showData(datas, input);
Console.Write("請按任意鍵結束...");
Console.ReadKey();
}
public async Task Delete_Resturns_WhenEntityDeleted()
{
//Arrage
var context = new Mock <DbContext>();
context.Setup(x => x.Set <Entity>().FindAsync(It.IsAny <int>())).ReturnsAsync(new Mock <Entity>().Object);
var service = new CrudService <Entity>(context.Object);
//Act
await service.DeleteAsync(default(int));
//Assert
context.Verify(x => x.Remove(It.IsAny <Entity>()), Times.Once);
context.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);
}
protected override async Task AddEntities()
{
await CrudService.AddAsync(new Role("SexRead"));
await CrudService.AddAsync(new Role("StudentRead"));
await CrudService.AddAsync(new Role("StudentCrud"));
await CrudService.AddAsync(new Role("GroupRead"));
await CrudService.AddAsync(new Role("GroupCrud"));
await CrudService.AddAsync(new Role("StudentGroupRead"));
await CrudService.AddAsync(new Role("StudentGroupCrud"));
}
public void Delete_ThrowsDbUpdateException_WhenCannotDelete()
{
//Arrage
var context = new Mock <DbContext>();
var entity = new Mock <Entity>().Object;
context.Setup(x => x.Set <Entity>().FindAsync(It.IsAny <int>())).ReturnsAsync(entity);
context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).ThrowsAsync(new DbUpdateException());
var service = new CrudService <Entity>(context.Object);
//Act
Func <Task> func = () => service.DeleteAsync(default(int));
//Assert
Assert.ThrowsAsync <DbUpdateException>(func);
context.Verify(x => x.Remove(It.IsAny <Entity>()), Times.Once);
}
public async Task Update_Returns_UpdateSuccessfull()
{
//Arrage
var entity = new Mock <Entity>().Object;
var context = new Mock <DbContext>();
context.Setup(x => x.Set <Entity>().Update(It.IsAny <Entity>()));
var service = new CrudService <Entity>(context.Object);
//Act
await service.UpdateAsync(1, entity);
//Assert
Assert.Equal(1, entity.Id);
context.Verify(x => x.Set <Entity>().Update(It.IsAny <Entity>()), Times.Once);
context.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public async Task TestCarrierUserValidation()
{
var updateData = DATA;
updateData.AllUsers = false;
var result = await CrudService.Update(updateData, true, USER_COMM_ID);
var errors = new List <string>()
{
"User Communication does not target any users. Please select at least one target for the communication."
};
result.IsValid.Should().BeFalse();
result.ModelState.Should().HaveCount(1);
result.ModelState.Select(error => error.Value.Errors.First().ErrorMessage).Should().BeEquivalentTo(errors);
}
public async Task TestCarrierUserValidation()
{
var updateData = CARRIER_PROFILE_DATA;
updateData.CarrierSuccessSpecialistId = null;
updateData.CarrierSuccessTeamLeadId = null;
var result = await CrudService.Update(updateData, true, updateData.CarrierId);
var errors = new List <string>()
{
"Carrier Success Specialist is required",
"Carrier Team Lead is required"
};
result.IsValid.Should().BeFalse();
result.ModelState.Should().HaveCount(2);
result.ModelState.Select(error => error.Value.Errors.First().ErrorMessage).Should().BeEquivalentTo(errors);
}
public void TestCrudService()
{
int expectedId = 2;
string readId = "Adan";
string updateId = "Sonny";
MockStorage ms = new MockStorage();
CrudService cs = new CrudService(ms);
cs.Create("Adan"); //Adding to NameList
cs.Create("Jae");
cs.Create("Tiana");
cs.Delete("test"); //Deleting from NameList
Assert.AreEqual(expectedId, ms.NameList.Count); // compare 2 to the Namelist count
Assert.AreEqual(readId, ms.Select()); //comparing Adan to value in Select function
Assert.AreEqual(expectedId, ms.Update(readId, updateId)); // updating Adan to Sonny
Assert.AreEqual(updateId, ms.NameList.Where(n => n == "Sonny").FirstOrDefault()); //Checking to if Sonny exist in NameList
}
public void TestCrudService()
{
int expectedId = 3;
string expectedString = "Tiana";
string newName = "John";
int count = 2;
MockStorage ms = new MockStorage();
CrudService cs = new CrudService(ms);
cs.Create("Tiana");
cs.Create("Adan");
cs.Create("Britto");
Assert.AreEqual(expectedString, ms.Read());
Assert.AreEqual(expectedId, ms.Update(expectedString, newName));
Assert.AreEqual(newName, ms.NameList.Where(n => n == "John").FirstOrDefault());
cs.Delete("Britto");
Assert.AreEqual(count, ms.NameList.Count);
}
public static ListaColaboradorTO PesquisarPorFuncao(string funcao)
{
_Crud = CrudService <ColaboradorCrud> .ObterInstancia();
ListaColaboradorTO retorno = new ListaColaboradorTO();
try
{
retorno = _Crud.Listar();
if (retorno.Valido)
{
retorno.Lista = retorno.Lista.Where(x => x.Funcao.Contains(funcao)).ToList();
}
}
catch (Exception ex)
{
retorno.Valido = false;
retorno.Mensagem = string.Format("Erro: {0}", ex.Message);
}
return(retorno);
}
public static ListaDependenteTO PesquisarPorNome(string nomeDependente)
{
_Crud = CrudService <DependenteCrud> .ObterInstancia();
ListaDependenteTO retorno = new ListaDependenteTO();
try
{
retorno = _Crud.Listar();
if (retorno.Valido)
{
retorno.Lista = retorno.Lista.Where(x => x.Nome.Contains(nomeDependente)).ToList();
}
}
catch (Exception ex)
{
retorno.Valido = false;
retorno.Mensagem = string.Format("Erro: {0}", ex.Message);
}
return(retorno);
}
public static ListaEstacionamentoTO ListarPorApartamento(int idApartamento)
{
_Crud = CrudService <EstacionamentoCrud> .ObterInstancia();
ListaEstacionamentoTO retorno = new ListaEstacionamentoTO();
try
{
retorno = _Crud.Listar();
if (retorno.Valido)
{
retorno.Lista = retorno.Lista.Where(x => x.IdApartamento == idApartamento).ToList();
}
}
catch (Exception ex)
{
retorno.Valido = false;
retorno.Mensagem = string.Format("Erro: {0}", ex.Message);
}
return(retorno);
}
public static ListaOcorrenciaTO ListarPorMorador(int idMorador)
{
_Crud = CrudService <OcorrenciaCrud> .ObterInstancia();
ListaOcorrenciaTO retorno = new ListaOcorrenciaTO();
try
{
retorno = _Crud.Listar();
if (retorno.Valido)
{
retorno.Lista = retorno.Lista.Where(x => x.IdMorador == idMorador).ToList();
}
}
catch (Exception ex)
{
retorno.Valido = false;
retorno.Mensagem = string.Format("Erro: {0}", ex.Message);
}
return(retorno);
}
public static ListaReservaTO ListarPorTipoReserva(int idTipoReserva)
{
_Crud = CrudService <ReservaCrud> .ObterInstancia();
ListaReservaTO retorno = new ListaReservaTO();
try
{
retorno = _Crud.Listar();
if (retorno.Valido)
{
retorno.Lista = retorno.Lista.Where(x => x.IdTipoReserva == idTipoReserva).ToList();
}
}
catch (Exception ex)
{
retorno.Valido = false;
retorno.Mensagem = string.Format("Erro: {0}", ex.Message);
}
return(retorno);
}
public ViewProductAction(CrudService<Product> crudService)
{
_crudService = crudService;
}
