public async Task SeededWater_InsertOrUpdate_IngredientUpdated()
{
//Arrange
var ingredient = new IngredientDetailModel
(
Name: IngredientSeeds.Water.Name,
Description: IngredientSeeds.Water.Description
)
{
Id = IngredientSeeds.Water.Id
};
ingredient.Name += "updated";
ingredient.Description += "updated";
//Act
await _ingredientFacadeSUT.SaveAsync(ingredient);
//Assert
await using var dbxAssert = await DbContextFactory.CreateDbContextAsync();
var ingredientFromDb = await dbxAssert.Ingredients.SingleAsync(i => i.Id == ingredient.Id);
DeepAssert.Equal(ingredient, Mapper.Map <IngredientDetailModel>(ingredientFromDb));
}
public async Task Create_With_Invalid_Name_Returns_Expected_Validation_Error(string name)
{
// Arrange
var newIngredient = new IngredientDetailModel
{
Name = name,
Description = "Mléko plnotučné"
};
var newIngredientSerialized = JsonConvert.SerializeObject(newIngredient);
var stringContent = new StringContent(newIngredientSerialized, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync("api/ingredient?version=3.0&culture=en", stringContent);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
//var problemDetails = JsonConvert.DeserializeObject<ProblemDetails>(await response.Content.ReadAsStringAsync());
//var serializableError = JsonConvert.DeserializeObject<SerializableError>(await response.Content.ReadAsStringAsync());
var validationProblemDetails = JsonConvert.DeserializeObject <ValidationProblemDetails>(await response.Content.ReadAsStringAsync());
validationProblemDetails.Errors.Should().HaveCount(1);
validationProblemDetails.Errors["Name"][0].Should().Be("Ingredient name length must be between 3 and 100 characters");
validationProblemDetails.Title.Should().Be("One or more validation errors occurred.");
}
public Guid Create(IngredientDetailModel ingredient)
{
var ingredientEntity = mapper.Map <IngredientEntity>(ingredient);
ingredientEntity.Id = Guid.NewGuid();
return(ingredientRepository.Insert(ingredientEntity));
}
public static IngredientEntity MapEntity(IngredientDetailModel model) =>
new IngredientEntity
{
Id = model.Id,
Description = model.Description,
Name = model.Name
};
public static IngredientEntity MapIngredientDetailModelToEntity(IngredientDetailModel model)
{
return(new IngredientEntity
{
Id = model.Id,
Description = model.Description,
Name = model.Name
});
}
public void Update(IngredientDetailModel model)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = IngredientMapper.MapIngredientDetailModelToEntity(model);
dbContext.Ingredients.Update(entity);
dbContext.SaveChanges();
}
}
public IngredientDetailModel Create(IngredientDetailModel model)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = IngredientMapper.MapIngredientDetailModelToEntity(model);
dbContext.Ingredients.Add(entity);
dbContext.SaveChanges();
return(IngredientMapper.MapIngredientEntityToDetailModel(entity));
}
}
public static IngredientEntity MapEntity(IngredientDetailModel model, IEntityFactory entityFactory = null)
{
var entity = (entityFactory ?? new DummyEntityFactory()).Create <IngredientEntity>(model.Id);
entity.Id = model.Id;
entity.Description = model.Description;
entity.Name = model.Name;
return(entity);
}
public async Task Create_WithNonExistingItem_DoesNotThrow()
{
var model = new IngredientDetailModel
(
Name: @"Ingredience 1",
Description: @"Testovací ingredience"
);
var _ = await _ingredientFacadeSUT.SaveAsync(model);
}
public async Task Save()
{
var resultId = await IngredientFacade.SaveAsync(Data);
if (OnModification.HasDelegate)
{
await OnModification.InvokeAsync(resultId);
}
Data = new IngredientDetailModel();
}
public void Create_WithNonExistingItem_DoesNotThrow()
{
IngredientDetailModel model = new IngredientDetailModel
{
Description = "Testovací ingredience",
Name = "Ingredience 1"
};
IngredientDetailModel returnedModel = _ingredientRepositorySUT.InsertOrUpdate(model);
}
public async Task <Guid> SaveAsync(IngredientDetailModel data)
{
if (data.Id == Guid.Empty)
{
return(await ingredientClient.IngredientPostAsync(apiVersion, culture, data));
}
else
{
return(await ingredientClient.IngredientPutAsync(apiVersion, culture, data));
}
}
public IngredientDetailModel InsertOrUpdate(IngredientDetailModel model)
{
using var dbContext = _dbContextFactory.Create();
var entity = IngredientMapper.MapIngredientDetailModelToEntity(model);
dbContext.Ingredients.Update(entity);
dbContext.SaveChanges();
return(IngredientMapper.MapIngredientEntityToDetailModel(entity));
}
public void Save()
{
if (Model.Id == Guid.Empty)
{
Model = repository.Create(Model);
}
else
{
repository.Update(Model);
}
}
protected override async Task OnInitializedAsync()
{
if (Id == Guid.Empty)
{
Data = new IngredientDetailModel();
}
else
{
Data = await IngredientFacade.GetIngredientAsync(Id);
}
await base.OnInitializedAsync();
}
public void Create_WithNonExistingItem_DoesNotThrow()
{
var model = new IngredientDetailModel
{
Description = "Testovací ingredience",
Name = "Ingredience 1"
};
var returnedModel = fixture.Repository.Create(model);
Assert.NotNull(returnedModel);
fixture.Repository.Delete(returnedModel.Id);
}
protected override async Task OnInitializedAsync()
{
if (Id == Guid.Empty)
{
Data = new IngredientDetailModel();
}
else
{
var dataList = await httpClient.GetFromJsonAsync <List <IngredientDetailModel> >("sample-data/ingredients.json");
Data = dataList.Single(item => item.Id == Id);
}
await base.OnInitializedAsync();
}
public override async Task OnAppearing()
{
await base.OnAppearing();
if (viewModelParameter == null)
{
Ingredient = new IngredientDetailModel {
Id = Guid.Empty
};
}
else
{
Ingredient = await ingredientsFacade.GetIngredientAsync(viewModelParameter.Value);
}
}
public async Task NewIngredient_InsertOrUpdate_IngredientAdded()
{
//Arrange
var ingredient = new IngredientDetailModel(
Name: "Water",
Description: "Mineral water"
);
//Act
ingredient = await _ingredientFacadeSUT.SaveAsync(ingredient);
//Assert
await using var dbxAssert = await DbContextFactory.CreateDbContextAsync();
var ingredientFromDb = await dbxAssert.Ingredients.SingleAsync(i => i.Id == ingredient.Id);
DeepAssert.Equal(ingredient, Mapper.Map <IngredientDetailModel>(ingredientFromDb));
}
public void NewIngredient_InsertOrUpdate_IngredientAdded()
{
//Arrange
var ingredient = new IngredientDetailModel()
{
Name = "Water",
Description = "Mineral water"
};
//Act
ingredient = _fixture.Repository.InsertOrUpdate(ingredient);
//Assert
using var dbxAssert = _fixture.DbContextFactory.CreateDbContext();
var ingredientFromDb = dbxAssert.Ingredients.Single(i => i.Id == ingredient.Id);
Assert.Equal(ingredient, IngredientMapper.MapDetailModel(ingredientFromDb), IngredientDetailModel.AllMembersComparer);
}
public void NewIngredient_InsertOrUpdate_IngredientAdded()
{
//Arrange
var ingredient = new IngredientDetailModel()
{
Name = "Water",
Description = "Mineral water"
};
//Act
ingredient = _ingredientRepositorySUT.InsertOrUpdate(ingredient);
//Assert
using var dbxAssert = _dbContextFactory.Create();
var ingredientFromDb = dbxAssert.Ingredients.Single(i => i.Id == ingredient.Id);
Assert.Equal(ingredient, IngredientMapper.MapEntityToDetailModel(ingredientFromDb));
}
public void SeededWater_InsertOrUpdate_IngredientUpdated()
{
//Arrange
var ingredient = new IngredientDetailModel()
{
Id = IngredientSeeds.Water.Id,
Name = IngredientSeeds.Water.Name,
Description = IngredientSeeds.Water.Description,
};
ingredient.Name += "updated";
ingredient.Description += "updated";
//Act
_ingredientRepositorySUT.InsertOrUpdate(ingredient);
//Assert
using var dbxAssert = _dbContextFactory.Create();
var ingredientFromDb = dbxAssert.Ingredients.Single(i => i.Id == ingredient.Id);
Assert.Equal(ingredient, IngredientMapper.MapEntityToDetailModel(ingredientFromDb));
}
public async Task Create_Should_Create_New_Ingredient()
{
// Arrange
var newIngredient = new IngredientDetailModel
{
Name = "Mléko",
Description = "Mléko polotučné"
};
var newIngredientSerialized = JsonConvert.SerializeObject(newIngredient);
var stringContent = new StringContent(newIngredientSerialized, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync("api/ingredient", stringContent);
//var response = await _client.PostAsJsonAsync("api/ingredient", newIngredient); // Microsoft.AspNet.WebApi.Client NuGet package needs to be installed.
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var newIngredientGuid = JsonConvert.DeserializeObject <Guid>(await response.Content.ReadAsStringAsync());
newIngredientGuid.Should().NotBeEmpty();
}
public void SeededWater_InsertOrUpdate_IngredientUpdated()
{
//Arrange
var ingredient = new IngredientDetailModel()
{
Id = Seeds.Water.Id,
Name = Seeds.Water.Name,
Description = Seeds.Water.Description,
};
ingredient.Name += "updated";
ingredient.Description += "updated";
//Act
_fixture.Repository.InsertOrUpdate(ingredient);
//Assert
using var dbxAssert = _fixture.DbContextFactory.CreateDbContext();
var ingredientFromDb = dbxAssert.Ingredients.Single(i => i.Id == ingredient.Id);
Assert.Equal(ingredient, IngredientMapper.MapDetailModel(ingredientFromDb), IngredientDetailModel.AllMembersComparer);
}
public async Task Update_Should_Update_Existing_Ingredient()
{
// Arrange
Guid ingredientToUpdateGuid = new Guid("ba605acc-25b5-4ae7-a23f-09e5513badec");
var ingredientUpdateModel = new IngredientDetailModel
{
Id = ingredientToUpdateGuid,
Name = "Šlehačka",
Description = "Popis šlehačky 40%"
};
var ingredientUpdateModelSerialized = JsonConvert.SerializeObject(ingredientUpdateModel);
var stringContent = new StringContent(ingredientUpdateModelSerialized, Encoding.UTF8, "application/json");
// Act
var response = await _client.PutAsync("api/ingredient", stringContent);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var ingredientGuid = JsonConvert.DeserializeObject <Guid>(await response.Content.ReadAsStringAsync());
ingredientGuid.Should().Be(ingredientToUpdateGuid);
}
public async Task <Guid> InsertAsync(IngredientDetailModel ingredient)
{
return(await _ingredientClient.IngredientPostAsync("3", "cs", ingredient));
}
public void Load(Guid id)
{
Model = repository.GetById(id);
}
public ActionResult <Guid> Update(IngredientDetailModel ingredient)
{
return(ingredientFacade.Update(ingredient));
}
private void IngredientNew(IngredientNewMessage ingredientNewMessage) => Model = new IngredientDetailModel();
public Guid?Update(IngredientDetailModel ingredient)
{
var ingredientEntity = mapper.Map <IngredientEntity>(ingredient);
return(ingredientRepository.Update(ingredientEntity));
}
