public async Task <ActionResult <Data.Models.Store> > CreateNewStore(Data.Models.StoreForCreate newStore)
{
Data.Entities.Store dbNewStore = null;
try
{
dbNewStore = _mapper.Map <Data.Entities.Store>(newStore);
}
catch (Exception ex)
{
return(BadRequest("Input is in invalid format: " + ex.Message));
}
if (dbNewStore == null)
{
return(BadRequest("Input is in invalid format"));
}
await _repository.AddAsync <Data.Entities.Store>(dbNewStore);
await _repository.SaveChangesAsync();
Data.Models.Store addedStore = _mapper.Map <Data.Models.Store>(dbNewStore);
var url = _linkgenerator.GetPathByAction(HttpContext, "GetStoreByStoreId", "Stores", addedStore);
return(this.Created(url, addedStore));
}
internal async Task Delete_Should_Return_NoContent_Record()
{
// Arrange
var client = _factory.CreateClient();
Data.Entities.Store store;
using (var scope = _factory.Server.Host.Services.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <StoreDbContext>();
store = new Data.Entities.Store
{
Key = "TestKey1",
Value = "TestValue1",
ExpirationTime = DateTime.Now.AddDays(1)
};
await dbContext.Stores.AddAsync(store);
await dbContext.SaveChangesAsync();
}
var requestUri = $"/api/keys/{store.Id}";
// Act
var response = await client.DeleteAsync(requestUri);
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task <ActionResult <Data.Models.Store> > PatchStore(string storeId, JsonPatchDocument <Data.Models.StoreForUpdate> patchDocument)
{
try
{
Data.Entities.Store dbStore = await _repository.GetStoreAsync(storeId);
if (dbStore == null)
{
return(NotFound());
}
var updatedStore = _mapper.Map <Data.Models.StoreForUpdate>(dbStore);
patchDocument.ApplyTo(updatedStore, ModelState);
_mapper.Map(updatedStore, dbStore);
if (await _repository.SaveChangesAsync())
{
Data.Models.Store savedStore = _mapper.Map <Data.Models.Store>(await _repository.GetStoreAsync(storeId));
return(Ok(savedStore));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to save to database"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to patch store " + ex.Message));
}
}
public async Task <ActionResult <Data.Models.Store> > UpdateStore(string storeId, Data.Models.StoreForUpdate updatedStore)
{
try
{
Data.Entities.Store dbStore = await _repository.GetStoreAsync(storeId);
if (dbStore == null)
{
return(NotFound());
}
_mapper.Map(updatedStore, dbStore);
if (await _repository.SaveChangesAsync())
{
Data.Models.Store savedStore = _mapper.Map <Data.Models.Store>(dbStore);
return(Ok(savedStore));
}
else
{
return(BadRequest("Failed to update."));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public static StoreGetResponse ConvertToStoreGetResponse(this Data.Entities.Store store)
{
return(new StoreGetResponse
{
Key = store.Key,
Value = store.Value,
ExpirationTime = store.ExpirationTime,
Id = store.Id
});
}
internal async Task Put_Should_Return_Updated_Record()
{
// Arrange
var client = _factory.CreateClient();
Data.Entities.Store store;
using (var scope = _factory.Server.Host.Services.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <StoreDbContext>();
store = new Data.Entities.Store
{
Key = "TestKey1",
Value = "TestValue1",
ExpirationTime = DateTime.Now.AddDays(1)
};
await dbContext.Stores.AddAsync(store);
await dbContext.SaveChangesAsync();
}
var requestUri = $"/api/keys/{store.Id}";
var requestModel = new
{
Key = "TestKey2",
Value = "TestValue2",
ExpirationTime = DateTime.Now.AddDays(2)
};
// Act
var response = await client.PutAsJsonAsync(requestUri, requestModel);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var responseString = await response.Content.ReadAsStringAsync();
Assert.NotEmpty(responseString);
var jObject = JObject.Parse(responseString);
Assert.True(jObject.ContainsKey("id"));
Assert.NotEqual(0, jObject["id"].Value <int>());
Assert.True(jObject.ContainsKey("key"));
Assert.Equal("TestKey2", jObject["key"].Value <string>());
Assert.True(jObject.ContainsKey("value"));
Assert.Equal("TestValue2", jObject["value"].Value <string>());
Assert.True(jObject.ContainsKey("expirationTime"));
}
internal async Task Put_Should_Update_Expiration_By_Query()
{
// Arrange
var client = _factory.CreateClient();
Data.Entities.Store store;
using (var scope = _factory.Server.Host.Services.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <StoreDbContext>();
store = new Data.Entities.Store
{
Key = "TestKey1",
Value = "TestValue1",
ExpirationTime = DateTime.Now.AddDays(1)
};
await dbContext.Stores.AddAsync(store);
await dbContext.SaveChangesAsync();
}
double?expireIn = 3600;
var requestUri = $"/api/keys/{store.Id}/{expireIn}";
var requestModel = new
{
Key = "TestKey2",
Value = "TestValue2",
};
// Act
var response = await client.PutAsJsonAsync(requestUri, requestModel);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var responseString = await response.Content.ReadAsStringAsync();
Assert.NotEmpty(responseString);
var jObject = JObject.Parse(responseString);
Assert.Equal(DateTime.Now.AddSeconds(3600).Hour, jObject["expirationTime"].Value <DateTime?>().Value.Hour);
Assert.Equal(DateTime.Now.AddSeconds(3600).Minute, jObject["expirationTime"].Value <DateTime?>().Value.Minute);
Assert.Equal(DateTime.Now.AddSeconds(3600).Second, jObject["expirationTime"].Value <DateTime?>().Value.Second);
}
internal async Task Put_Should_Return_Error_When_Record_Already_Exists()
{
// Arrange
var client = _factory.CreateClient();
Data.Entities.Store store;
using (var scope = _factory.Server.Host.Services.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <StoreDbContext>();
store = new Data.Entities.Store
{
Key = "TestKey1",
Value = "TestValue1",
ExpirationTime = DateTime.Now.AddDays(1)
};
await dbContext.Stores.AddAsync(store);
await dbContext.SaveChangesAsync();
}
var requestUri = $"/api/keys/{store.Id}";
var requestModel = new
{
Key = "TestKey1",
Value = "TestValue1",
ExpirationTime = DateTime.Now.AddDays(2)
};
// Act
var response = await client.PutAsJsonAsync(requestUri, requestModel);
// Assert
var responseModel = await response.Content.ReadAsAsync <string[]>();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Single(responseModel);
Assert.Equal("This record already exists.", responseModel[0]);
}
public async Task <IActionResult> DeleteStore(string storeId)
{
try
{
Data.Entities.Store dbStore = await _repository.GetStoreAsync(storeId);
if (dbStore == null)
{
return(NotFound());
}
_repository.Delete <Data.Entities.Store>(dbStore);
await _repository.SaveChangesAsync();
return(NoContent());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public async Task <BaseResponse <StorePostResponse> > Post(StorePutRequest request)
{
var response = new BaseResponse <StorePostResponse>();
if (string.IsNullOrEmpty(request.Key))
{
response.Errors.Add("Key cannot be null or empty.");
}
if (string.IsNullOrEmpty(request.Value))
{
response.Errors.Add("Value cannot be null or empty.");
}
if (!request.ExpirationTime.HasValue)
{
request.ExpirationTime = DateTime.Now.AddDays(1);
}
var store = new Data.Entities.Store
{
Key = request.Key,
Value = request.Value,
ExpirationTime = request.ExpirationTime
};
if (await _repository.Head(store.Key, store.Value))
{
response.Errors.Add("This record already exists.");
}
if (!response.HasError)
{
var entity = await _repository.Post(store);
response.Data = entity.ConvertToStorePostResponse();
}
return(response);
}
