public async void CreateHiveSuccesFull()
{
var productContext = new Mock <IProductStoreHiveContext>();
productContext.Setup(p => p.Hives).ReturnsEntitySet(new List <StoreHive>());
var userContext = new Mock <IUserContext>();
userContext.Setup(u => u.UserId).Returns(1);
var dbHive = new StoreHive
{
Id = 1,
Code = "12314321"
};
var myProductMock =
new ProductStoreContextMock(new FakeEntitySet <StoreHive>(new List <StoreHive> {
dbHive
}), null, null);
var service = new HiveService(productContext.Object, userContext.Object);
var createRequest = new UpdateHiveRequest
{
Name = "newHive",
Address = "address",
Code = "111341"
};
await service.CreateHiveAsync(createRequest);
//Assert.NotNull(service.GetHivesAsync());
}
public async Task UpdateHiveAsync_IdNotPresent_RequestedResourceNotFoundExceptionThrown()
{
var newHive = new UpdateHiveRequest()
{
Code = "bb"
};
var mockUserContext = new Mock <IUserContext>();
var mockHiveContext = new Mock <IProductStoreHiveContext>();
List <StoreHive> hiveList = new List <StoreHive>()
{
new StoreHive()
{
Id = 1, Code = "aa"
},
new StoreHive()
{
Id = 2, Code = "bb"
}
};
mockHiveContext.Setup(c => c.Hives).ReturnsEntitySet(hiveList);
var service = new HiveService(mockHiveContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.UpdateHiveAsync(3, newHive));
}
public async Task UpdateHiveAsync_ValidRequest_HiveUpdated()
{
var newHive = new UpdateHiveRequest()
{
Code = "cc"
};
var mockUserContext = new Mock <IUserContext>();
var mockHiveContext = new Mock <IProductStoreHiveContext>();
List <StoreHive> hiveList = new List <StoreHive>()
{
new StoreHive()
{
Id = 1, Code = "aa"
},
new StoreHive()
{
Id = 2, Code = "bb"
}
};
mockHiveContext.Setup(c => c.Hives).ReturnsEntitySet(hiveList);
var service = new HiveService(mockHiveContext.Object, mockUserContext.Object);
var updatedHive = await service.UpdateHiveAsync(1, newHive);
Assert.Equal(newHive.Code, updatedHive.Code);
}
public async Task CreateHiveAsync_UniqueCode_HiveWithSpecifiedCodeCreated()
{
const string newCode = "cc";
var newHive = new UpdateHiveRequest()
{
Code = newCode
};
var mockUserContext = new Mock <IUserContext>();
var mockHiveContext = new Mock <IProductStoreHiveContext>();
List <StoreHive> hiveList = new List <StoreHive>()
{
new StoreHive()
{
Id = 1, Code = "aa"
},
new StoreHive()
{
Id = 2, Code = "bb"
}
};
mockHiveContext.Setup(c => c.Hives).ReturnsEntitySet(hiveList);
var service = new HiveService(mockHiveContext.Object, mockUserContext.Object);
var hive = await service.CreateHiveAsync(newHive);
Assert.Equal(newCode, hive.Code);
}
public async Task <IHttpActionResult> UpdateHive([FromUri] int hiveId, [FromBody] UpdateHiveRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (hiveId < 1)
{
return(BadRequest($"{Resources.INVALI_ID_VALUE}{hiveId}"));
}
try
{
await _hiveService.UpdateHiveAsync(hiveId, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
catch (RequestedResourceHasConflictException)
{
return(Conflict());
}
catch (RequestedResourceNotFoundException)
{
return(NotFound());
}
catch (Exception e)
{
return(InternalServerError());
}
}
public async Task <IHttpActionResult> AddHive([FromBody] UpdateHiveRequest createRequest)
{
if (createRequest == null)
{
return(BadRequest(Resources.NULL_OBJECT_VALUE));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var hive = await _hiveService.CreateHiveAsync(createRequest);
var location = $"/api/hives/{hive.Id}";
return(Created <Hive>(location, hive));
}
catch (RequestedResourceHasConflictException)
{
return(Conflict());
}
catch (Exception e)
{
return(InternalServerError());
}
}
public async Task <IHttpActionResult> UpdateHiveAsync([FromUri] int?hiveId, [FromBody] UpdateHiveRequest updateHiveRequest)
{
if (hiveId == null || updateHiveRequest == null || !ModelState.IsValid)
{
return(BadRequest());
}
try
{
await _hiveService.UpdateHiveAsync(hiveId.Value, updateHiveRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
catch (RequestedResourceHasConflictException e)
{
return(Conflict());
}
catch (RequestedResourceNotFoundException e)
{
return(NotFound());
}
catch (Exception e)
{
return(InternalServerError());
}
}
public async Task UpdateHive_UpdateHiveToExistedCode_ExceptionThrown(
[Frozen] Mock <IProductStoreHiveContext> context,
HiveService service)
{
var existedhive = new StoreHive
{
Id = 1,
Code = "Code"
};
var updatedExistedHive = new StoreHive
{
Id = 2,
Code = "Code1"
};
var newHive = new UpdateHiveRequest
{
Code = "Code"
};
context.Setup(c => c.Hives).ReturnsAsyncEntitySet(new[] { existedhive, updatedExistedHive });
await Assert.ThrowsAsync <RequestedResourceHasConflictException>(async() => await service.UpdateHiveAsync(2, newHive));
}
public async Task UpdateHiveAsync_ChangeHiveProperties_UpdatedHiveReturned()
{
var hives = new List <StoreHive>()
{
new StoreHive()
{
Id = 0, Code = "CODE1"
},
new StoreHive()
{
Id = 1, Code = "CODE2"
}
};
var context = new Mock <IProductStoreHiveContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(hives);
var service = new HiveService(context.Object, new UserContext());
var request = new UpdateHiveRequest {
Code = "CODE3", Name = "New Name", Address = "New Address"
};
var hive = await service.UpdateHiveAsync(1, request);
Assert.Equal(request.Code, hive.Code);
Assert.Equal(request.Name, hive.Name);
Assert.Equal(request.Address, hive.Address);
}
public async Task UpdateHiveAsync_ChangeCodeToExistingHiveCode_ExceptionThrown()
{
var hives = new List <StoreHive>()
{
new StoreHive()
{
Id = 0, Code = "CODE1"
},
new StoreHive()
{
Id = 1, Code = "CODE2"
}
};
var context = new Mock <IProductStoreHiveContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(hives);
var service = new HiveService(context.Object, new UserContext());
var request = new UpdateHiveRequest {
Code = "CODE1"
};
await Assert.ThrowsAsync <RequestedResourceHasConflictException>(async() =>
{
await service.UpdateHiveAsync(1, request);
});
}
public async Task <IHttpActionResult> UpdateHiveAsync([FromUri] int id, [FromBody] UpdateHiveRequest updateRequest)
{
if (id < 1)
{
return(BadRequest($"Argument {nameof(id)} must be greater than zero."));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await _hiveService.UpdateHiveAsync(id, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
catch (RequestedResourceHasConflictException)
{
return(Conflict());
}
catch (RequestedResourceNotFoundException)
{
return(NotFound());
}
}
public async Task UpdateHiveAsync_SuccessfulTest(int id, string name, string code, string address)
{
var context = new Mock <IProductStoreHiveContext>();
var userContext = new Mock <IUserContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(new List <StoreHive>()
{
new StoreHive()
{
Id = 1, Code = "11111"
}
});
var service = new HiveService(context.Object, userContext.Object);
var request = new UpdateHiveRequest
{
Name = name,
Code = code,
Address = address
};
await service.UpdateHiveAsync(id, request);
var actualHive = await service.GetHiveAsync(id);
Assert.Equal(code, actualHive.Code);
}
public async Task <IHttpActionResult> CreateHiveAsync([FromBody] UpdateHiveRequest hive)
{
if (hive == null)
{
return(this.BadRequest(Resources.ModelIsInvalid));
}
if (!ModelState.IsValid)
{
return(this.BadRequest(Resources.ModelIsInvalid));
}
try
{
var result = await this._hiveService.CreateHiveAsync(hive);
var location = $"api/hives/{result.Id}";
return(this.Created <Hive>(location, result));
}
catch (RequestedResourceHasConflictException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex.Message)));
}
catch (Exception)
{
return(this.InternalServerError());
}
}
public async Task <IHttpActionResult> UpdateHiveAsync([FromUri] int id, [FromBody] UpdateHiveRequest hive)
{
if (hive == null)
{
return(this.BadRequest(Resources.ModelIsInvalid));
}
if (!ModelState.IsValid)
{
return(this.BadRequest(Resources.ModelIsInvalid));
}
try
{
var result = await this._hiveService.UpdateHiveAsync(id, hive);
return(this.Ok(result));
}
catch (RequestedResourceHasConflictException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex.Message)));
}
catch (RequestedResourceNotFoundException ex)
{
return(this.BadRequest(ex.Message));
}
catch (Exception)
{
return(this.InternalServerError());
}
}
public async Task <IHttpActionResult> UpdateHiveAsync([FromUri] int id, [FromBody] UpdateHiveRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _hiveService.UpdateHiveAsync(id, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task <IHttpActionResult> UpdateHive1([FromUri] int id, [FromBody] UpdateHiveRequest updateHiveRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _hiveService.UpdateHiveAsync(id, updateHiveRequest);
return(Ok());
}
public async Task <IHttpActionResult> UpdateHive([FromBody] UpdateHiveRequest hiveRequest, [FromUri] int hiveId)
{
if (!ModelState.IsValid)
{
return(BadRequest($"model state is not valid {ModelState}"));
}
await _hiveService.UpdateHiveAsync(hiveId, hiveRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task <IHttpActionResult> UpdateHive([FromUri] int hiveId, [FromBody] UpdateHiveRequest hiveRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var hive = await this._hiveService.UpdateHiveAsync(hiveId, hiveRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent, hive)));
}
public async Task<IHttpActionResult> AddHiveAsync([FromBody] UpdateHiveRequest createRequest)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var hive = await _hiveService.CreateHiveAsync(createRequest);
var location = string.Format("/api/hives/{0}", hive.Id);
return Created<Hive>(location, hive);
}
public async Task <IHttpActionResult> AddHive(UpdateHiveRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var hive = await _hiveService.CreateHiveAsync(request);
var location = string.Format($"/api/hives/{hive.Id}");
return(Created(location, hive));
}
public async Task <IHttpActionResult> AddHive([FromBody] UpdateHiveRequest createRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var have = await _hiveService.CreateHiveAsync(createRequest);
var location = $"/api/hives/{have.Id}";
return(Created <Hive>(location, have));
}
public async Task <IHttpActionResult> AddHive([FromBody] UpdateHiveRequest updateHiveRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var createdHive = await this._hiveService.CreateHiveAsync(updateHiveRequest);
var location = string.Format("/api/hives/{0}", createdHive.Id);
return(Created <Hive>(location, createdHive));
}
public async Task <IHttpActionResult> UpdateHive([FromUri] int hiveId, [FromBody] UpdateHiveRequest updateRequest)
{
IHttpActionResult result = CheckRequest(updateRequest);
if (result != null)
{
return(result);
}
await _hiveService.UpdateHiveAsync(hiveId, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task UpdateHiveAsync_UpdateNonExistentHive_ExceptionThrown()
{
var context = new Mock <IProductStoreHiveContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(new List <StoreHive>());
var service = new HiveService(context.Object, new UserContext());
var request = new UpdateHiveRequest();
await Assert.ThrowsAsync <RequestedResourceNotFoundException>(async() =>
{
await service.UpdateHiveAsync(0, request);
});
}
public async Task <IHttpActionResult> AddHive([FromBody] UpdateHiveRequest createRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest($"model state is not valid {ModelState}"));
}
var newHive = await _hiveService.CreateHiveAsync(createRequest);
string location = $"/api/hives/{newHive.Id}";
return(Created(location, newHive));
}
private IHttpActionResult CheckRequest(UpdateHiveRequest request)
{
if (request == null)
{
return(BadRequest("The request does not contain body"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(null);
}
public async Task <IHttpActionResult> AddHive([FromBody] UpdateHiveRequest createRequest)
{
IHttpActionResult result = CheckRequest(createRequest);
if (result != null)
{
return(result);
}
Hive hive = await _hiveService.CreateHiveAsync(createRequest);
string location = $"/api/hives/{hive.Id}";
return(Created <Hive>(location, hive));
}
public async Task CreateHive_RequestedResourceHasConflictException(
[Frozen] Mock <IProductStoreHiveContext> context,
HiveService service,
IFixture fixture)
{
var collection = fixture.CreateMany <StoreHive>(5).ToArray();
var hive = new UpdateHiveRequest {
Code = collection[0].Code
};
context.Setup(x => x.Hives).ReturnsEntitySet(collection);
Func <Task> act = async() => await service.CreateHiveAsync(hive);
act.Should().Throw <RequestedResourceHasConflictException>();
}
public async Task CreateHiveAsync_EmptyCollection_NewHiveReturned()
{
var context = new Mock <IProductStoreHiveContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(new List <StoreHive>());
var service = new HiveService(context.Object, new UserContext());
var request = new UpdateHiveRequest {
Code = "CODE1", Name = "Hive", Address = "Test"
};
var hive = await service.CreateHiveAsync(request);
Assert.Equal(request.Code, hive.Code);
Assert.Equal(request.Name, hive.Name);
Assert.Equal(request.Address, hive.Address);
}
public void UpdateHiveAsync_NoHiveWithSuchIdTest(int id, string name, string code, string address)
{
var context = new Mock <IProductStoreHiveContext>();
var userContext = new Mock <IUserContext>();
context.Setup(c => c.Hives).ReturnsEntitySet(new List <StoreHive>());
var service = new HiveService(context.Object, userContext.Object);
var request = new UpdateHiveRequest
{
Name = name,
Code = code,
Address = address
};
Assert.ThrowsAsync <RequestedResourceNotFoundException>(async() => await service.UpdateHiveAsync(id, request));
}
