public void AddMedicine_CorrectData_AddedNewMedicine()
{
// Arrange
var model = new MedicineInputModel
{
Name = "Nowy lek",
ContentQuantity = "100ml",
Price = 23.49M,
Description = "Nowy jeszcze lepszy super lek",
Producer = "Pharma",
MedicineTypeId = 1
};
mock.Setup(x => x.CreateNewMedicine(model)).Returns(() =>
new OperationResult <string>(ResultResources.CreatingMedicineComplete));
var medicinesController = new MedicinesController(mock.Object);
// Act
var result = medicinesController.AddMedicine(model) as OkObjectResult;
var response = result.Value as Result <string>;
// Assert
Assert.AreEqual((int)HttpStatusCode.OK, result.StatusCode);
Assert.IsNotNull(response.Items);
Assert.AreEqual(ResultResources.CreatingMedicineComplete, response.Items);
}
public void CreateNewMedicine_BadMedicineTypeId_BadRequestError()
{
// Arrange
var model = new MedicineInputModel
{
Name = "Nowy lek",
ContentQuantity = "100ml",
Price = 23.49M,
Description = "Nowy jeszcze lepszy super lek",
Producer = "Pharma",
MedicineTypeId = 0
};
mockContext.Setup(x => x.MedicineTypes).Returns(mockMedicineType.Object);
mockContext.Setup(x => x.Medicines).Returns(mockMedicine.Object);
var medicinesRepository = new MedicinesRepository(mockContext.Object);
// Act
var result = medicinesRepository.CreateNewMedicine(model);
// Assert
Assert.IsNotNull(result);
Assert.False(result.IsSuccess);
Assert.IsNull(result.Result);
Assert.AreEqual(1, result.Errors.Count());
Assert.AreEqual(ErrorResources.InvalidInsertDatabaseData, result.Errors.Single().Message);
Assert.AreEqual((int)ErrorCodes.BadRequest, result.Errors.Single().ErrorCode);
}
public void CreateNewMedicine_DatabaseError_InternalServerError()
{
// Arrange
var model = new MedicineInputModel
{
Name = "Nowy lek",
ContentQuantity = "100ml",
Price = 23.49M,
Description = "Nowy jeszcze lepszy super lek",
Producer = "Pharma",
MedicineTypeId = 1
};
var medicinesRepository = new MedicinesRepository(It.IsAny <PharmaStoreContext>());
// Act
var result = medicinesRepository.CreateNewMedicine(model);
// Assert
Assert.IsNotNull(result);
Assert.False(result.IsSuccess);
Assert.IsNull(result.Result);
Assert.AreEqual(1, result.Errors.Count());
Assert.AreEqual(ErrorResources.DatabaseError, result.Errors.Single().Message);
Assert.AreEqual((int)ErrorCodes.InternalServerError, result.Errors.Single().ErrorCode);
}
public void CreateNewMedicine_CorrectData_CreatedMedicine()
{
// Arrange
var model = new MedicineInputModel
{
Name = "Nowy lek",
ContentQuantity = "100ml",
Price = 23.49M,
Description = "Nowy jeszcze lepszy super lek",
Producer = "Pharma",
MedicineTypeId = 1
};
mockContext.Setup(x => x.MedicineTypes).Returns(mockMedicineType.Object);
mockContext.Setup(x => x.Medicines).Returns(mockMedicine.Object);
var medicinesRepository = new MedicinesRepository(mockContext.Object);
// Act
var result = medicinesRepository.CreateNewMedicine(model);
// Assert
Assert.IsNull(result.Errors);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Result.TotalCount);
Assert.AreEqual(ResultResources.CreatingMedicineComplete, result.Result.Items);
Assert.True(result.IsSuccess);
}
public string Add(MedicineInputModel inputModel)
{
Medicine medicine = new Medicine()
{
Name = inputModel.Name,
DaylyDoze = inputModel.DaylyDoze
};
this.db.Medicines.Add(medicine);
this.db.SaveChanges();
return(medicine.Id);
}
private IEnumerable <OperationError> MedicineValidation(MedicineInputModel medicine)
{
var errors = new List <OperationError>();
if (string.IsNullOrEmpty(medicine.Name))
{
errors.Add(new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty, nameof(medicine.Name)));
}
else if (medicine.Name.Length < 2 || medicine.Name.Length > 50)
{
var errorMessage = string.Format(ErrorResources.InvalidFieldLength, 1, 50);
errors.Add(new OperationError((int)ErrorCodes.BadRequest, errorMessage, nameof(medicine.Name)));
}
if (string.IsNullOrEmpty(medicine.ContentQuantity))
{
errors.Add(new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty, nameof(medicine.ContentQuantity)));
}
else if (medicine.ContentQuantity.Length < 3 || medicine.ContentQuantity.Length > 10)
{
var errorMessage = string.Format(ErrorResources.InvalidFieldLength, 2, 10);
errors.Add(new OperationError((int)ErrorCodes.BadRequest, errorMessage, nameof(medicine.ContentQuantity)));
}
if (string.IsNullOrEmpty(medicine.Producer))
{
errors.Add(new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty, nameof(medicine.Producer)));
}
else if (medicine.Producer.Length < 2 || medicine.Producer.Length > 50)
{
var errorMessage = string.Format(ErrorResources.InvalidFieldLength, 1, 50);
errors.Add(new OperationError((int)ErrorCodes.BadRequest, errorMessage, nameof(medicine.Producer)));
}
if (string.IsNullOrEmpty(medicine.Description))
{
errors.Add(new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty, nameof(medicine.Description)));
}
else if (medicine.Description.Length < 2 || medicine.Description.Length > 2000)
{
var errorMessage = string.Format(ErrorResources.InvalidFieldLength, 1, 2000);
errors.Add(new OperationError((int)ErrorCodes.BadRequest, errorMessage, nameof(medicine.Description)));
}
return(errors);
}
public void CreateNewMedicine_InvalidDataNullModelFields_BadRequestErrors()
{
// Arrange
var model = new MedicineInputModel();
var medicinesRepository = new MedicinesRepository(It.IsAny <PharmaStoreContext>());
// Act
var result = medicinesRepository.CreateNewMedicine(model);
// Assert
Assert.IsNull(result.Result);
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Errors.Count());
Assert.AreEqual(1, result.Errors.Select(x => x.Message).Distinct().Count());
Assert.False(result.IsSuccess);
}
public void AddMedicine(string prescriptionId, MedicineInputModel inputModel)
{
string medicineId = this.medicinesService.GetMedicineId(inputModel.Name);
if (string.IsNullOrEmpty(medicineId))
{
medicineId = this.medicinesService.Add(inputModel);
}
PrescriptionMedicine prescriptionMedicine = new PrescriptionMedicine()
{
PrescriptionId = prescriptionId,
MedicineId = medicineId
};
this.db.PrescriptionMedicines.Add(prescriptionMedicine);
this.db.SaveChanges();
}
public IActionResult AddMedicine([FromBody][Required] MedicineInputModel newMedicine)
{
if (ModelState.IsValid && newMedicine != null)
{
newMedicine = newMedicine.TrimObj();
var result = _medicinesRepository.CreateNewMedicine(newMedicine);
if (result.IsSuccess)
{
return(Ok(result.Result));
}
return(BadRequest(result.Errors));
}
return(BadRequest(GlobalHelpers.ModelStateError()));
}
public void CreateNewMedicine_InvalidDataTooShortModelFields_BadRequestErrors()
{
// Arrange
var model = new MedicineInputModel
{
Name = "a",
ContentQuantity = "aa",
Description = "a",
Producer = "a"
};
var medicinesRepository = new MedicinesRepository(It.IsAny <PharmaStoreContext>());
// Act
var result = medicinesRepository.CreateNewMedicine(model);
// Assert
Assert.IsNull(result.Result);
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Errors.Count());
Assert.False(result.IsSuccess);
}
public void AddMedicine_InvalidData_ManyValidationErrors()
{
// Arrange
var model = new MedicineInputModel
{
Name = "",
ContentQuantity = "1",
Price = 23.49M,
Description = " ",
Producer = " P ",
MedicineTypeId = 0
};
mock.Setup(x => x.CreateNewMedicine(model))
.Returns(() =>
new OperationResult <string>(new List <OperationError>
{
new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty,
nameof(model.Name)),
new OperationError((int)ErrorCodes.BadRequest,
string.Format(ErrorResources.InvalidFieldLength, 2, 10), nameof(model.ContentQuantity)),
new OperationError((int)ErrorCodes.BadRequest, ErrorResources.FieldCannotBeEmpty,
nameof(model.Description))
}));
var medicinesController = new MedicinesController(mock.Object);
// Act
var result = medicinesController.AddMedicine(model) as BadRequestObjectResult;
var response = result.Value as IEnumerable <OperationError>;
// Assert
Assert.AreEqual((int)HttpStatusCode.BadRequest, result.StatusCode);
Assert.IsNotNull(response);
Assert.AreEqual(3, response.Count());
Assert.AreEqual((int)ErrorCodes.BadRequest, response.First().ErrorCode);
}
public OperationResult <string> CreateNewMedicine(MedicineInputModel newMedicine)
{
var errorList = MedicineValidation(newMedicine);
if (errorList.Any())
{
return(new OperationResult <string>(errorList));
}
try
{
if (!_context.MedicineTypes.Select(x => x.Id).Contains(newMedicine.MedicineTypeId))
{
return(new OperationResult <string>(new OperationError((int)ErrorCodes.BadRequest, ErrorResources.InvalidInsertDatabaseData)));
}
_context.Medicines.Add(new Models.Medicines.Medicine
{
Name = newMedicine.Name,
MedicineTypeId = newMedicine.MedicineTypeId,
Producer = newMedicine.Producer,
Price = newMedicine.Price,
ContentQuantity = newMedicine.ContentQuantity,
Description = newMedicine.Description
});
_context.SaveChanges();
return(new OperationResult <string>(ResultResources.CreatingMedicineComplete));
}
catch
{
return(new OperationResult <string>(new OperationError((int)ErrorCodes.InternalServerError,
ErrorResources.DatabaseError)));
}
}
public async Task <JsonResult> AddMedicine(MedicineInputModel medicine)
{
string urlBuild = url;
try
{
var stringContent = new StringContent(JsonConvert.SerializeObject(medicine), Encoding.UTF8, "application/json");
HttpResponseMessage response = await new HttpClient().PostAsync(urlBuild, stringContent);
if (response.StatusCode == HttpStatusCode.OK)
{
var model = await response.Content.ReadAsAsync <Result <string> >();
var result = new OperationResult <string>(model);
return(Json(new { type = "OK" }));
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
var model = await response.Content.ReadAsAsync <IEnumerable <Error> >();
var result = new OperationResult <string>(model);
if (result.Errors.All(x => !string.IsNullOrEmpty(x.FieldName)))
{
return(Json(new { type = "Validation", data = result.Errors }));
}
}
return(Json(new { type = "Error" }));
}
catch
{
return(Json(new { type = "Error" }));
}
}
