public async Task Add_ReturnsHairStyleLinkAdded()
{
// Arrange
_hairStyleLinksContext = _db.SeedHairStyleLinksContext();
int currentHairStyleLinksCount = _db.HairStyleLinks.Count;
List <HairStyleLinks> currentHairStyleLinks = _db.HairStyleLinks;
HairStyleLinks expected = new HairStyleLinks
{
Id = 3,
LinkName = "bob link 2",
LinkUrl = "https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/gettyimages-854996960-1508951083.jpg",
HairStyleId = 2
};
// Act
HairStyleLinks actual = await _hairStyleLinksContext.Add(expected);
int updatedHairStyleLinksCount = _db.HairStyleLinks.Count;
_db.HairStyleLinks = new List <HairStyleLinks>(currentHairStyleLinks);
// Assert
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(currentHairStyleLinksCount + 1, updatedHairStyleLinksCount);
}
public async Task Edit_ReturnsTrue()
{
// Arrange
_hairStyleLinksContext = _db.SeedHairStyleLinksContext();
ulong id = 2;
List <HairStyleLinks> currentHairStyleLinks = _db.HairStyleLinks;
HairStyleLinks current = currentHairStyleLinks.FirstOrDefault(c => c.Id == id);
HairStyleLinks updated = current.ShallowCopy();
updated.LinkName = "afro links updated";
updated.LinkUrl = "https://cdn.shopify.com/s/files/1/1767/9375/files/lyssamariexo_large.png?v=1568126512";
HairStyleLinks updatedHairStyleLink = new HairStyleLinks
{
Id = id,
LinkName = updated.LinkName,
LinkUrl = updated.LinkUrl,
HairStyleId = updated.HairStyleId
};
bool expected = true;
// Act
bool actual = await _hairStyleLinksContext.Edit(id, updatedHairStyleLink);
HairStyleLinks u = _db.HairStyleLinks.FirstOrDefault(fs => fs.Id == id);
_db.HairStyleLinks = new List <HairStyleLinks>(currentHairStyleLinks);
// Assert
Assert.Equal(expected, actual);
Assert.Equal(updatedHairStyleLink.LinkUrl, u.LinkUrl);
}
/// <summary>
/// Deletes a hairStyleLink by ID
/// </summary>
/// <param name="id">ID of the hairStyleLink to be deleted</param>
/// <exception cref="ResourceNotFoundException">
/// Thrown if the user with the corresponding <seealso cref="id"/> is not found
/// </exception>
/// <returns>HairStyleLink deleted</returns>
public async Task <HairStyleLinks> Delete(ulong id)
{
HairStyleLinks hairStyleLink = null;
if (_context != null)
{
hairStyleLink = await _context.HairStyleLinks.FindAsync(id);
if (hairStyleLink != null)
{
_context.HairStyleLinks.Remove(hairStyleLink);
await _context.SaveChangesAsync();
}
else
{
throw new ResourceNotFoundException("HairStyleLink not found");
}
}
else
{
hairStyleLink = HairStyleLinks.Where(u => u.Id == id).FirstOrDefault();
if (hairStyleLink != null)
{
HairStyleLinks.Remove(hairStyleLink);
}
else
{
throw new ResourceNotFoundException("HairStyleLink not found");
}
}
return(hairStyleLink);
}
public async Task Read_ReturnsHairStyleLinksById()
{
// Arrange
_hairStyleLinksContext = _db.SeedHairStyleLinksContext();
ulong id = 1;
HairStyleLinks expected = _db.HairStyleLinks.FirstOrDefault(c => c.Id == id);
// Act
HairStyleLinks actual = await _hairStyleLinksContext.ReadById(id);
// Assert
Assert.Equal(expected, actual);
}
/// <summary>
/// Adds a new hairStyleLink
/// <para>
/// NOTE: Currently this method is not restricted to unique hairStyleLinks, so the operation always succeeds
/// </para>
/// </summary>
/// <param name="hairStyleLink">HairStyleLink to be added</param>
/// <returns>HairStyleLink added</returns>
public Task <HairStyleLinks> Add(HairStyleLinks hairStyleLink)
{
HairStyleLinks hairStyleLinkAdded = null;
if (_context != null)
{
_context.HairStyleLinks.Add(hairStyleLink);
hairStyleLinkAdded = hairStyleLink;
}
else
{
HairStyleLinks.Add(hairStyleLink);
hairStyleLinkAdded = hairStyleLink;
}
return(Task.FromResult(hairStyleLinkAdded));
}
/// <summary>
/// Updates an existing hairStyleLink
/// </summary>
/// <param name="id">ID of the hairStyleLink to be updated</param>
/// <param name="updatedHairStyleLink">Updated hairStyleLink object</param>
/// <exception cref="ResourceNotFoundException">
/// Thrown if <seealso cref="updatedHairStyleLink"/> does not exist
/// </exception>
/// <exception cref="DbUpdateConcurrencyException">
/// </exception>
/// <returns>Result of the operation</returns>
public async Task <bool> Edit(ulong id, HairStyleLinks updatedHairStyleLink)
{
bool hairStyleLinkUpdated = false;
if (_context != null)
{
HairStyleLinks currentHairStyleLink = await _context.HairStyleLinks.FindAsync(id);
try
{
if (currentHairStyleLink != null)
{
currentHairStyleLink.LinkName = updatedHairStyleLink.LinkName;
currentHairStyleLink.LinkUrl = updatedHairStyleLink.LinkUrl;
_context.Entry(currentHairStyleLink).State = EntityState.Modified;
await _context.SaveChangesAsync();
hairStyleLinkUpdated = true;
}
throw new ResourceNotFoundException("HairStyleLink not found");
}
catch (DbUpdateConcurrencyException ex)
{
throw ex;
}
}
else
{
HairStyleLinks currentHairStyleLink = HairStyleLinks.FirstOrDefault(fs => fs.Id == id);
if (currentHairStyleLink != null)
{
int currentHairStyleLinkIndex = HairStyleLinks.FindIndex(c => c.Id == id);
HairStyleLinks[currentHairStyleLinkIndex] = updatedHairStyleLink;
hairStyleLinkUpdated = true;
}
else
{
throw new ResourceNotFoundException("HairStyleLink not found");
}
}
return(hairStyleLinkUpdated);
}
public async Task <ActionResult <HairStyleLinks> > PostHairStyleLinks([FromBody] HairStyleLinks hairStyleLinks)
{
if (!_authorizationService.ValidateJWTToken(Request))
{
return(Unauthorized(new { errors = new { Token = new string[] { "Invalid token" } }, status = 401 }));
}
var correspondingHairStyle = await _context.HairStyles.FirstOrDefaultAsync(h => h.Id == hairStyleLinks.HairStyleId);
if (correspondingHairStyle == null)
{
return(NotFound(new { errors = new { HairStyleId = new string[] { "No matching hair style entry was found" } }, status = 404 }));
}
_context.HairStyleLinks.Add(hairStyleLinks);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetHairStyleLinks", new { id = hairStyleLinks.Id }, hairStyleLinks));
}
public async Task Delete_ReturnsHairStyleLinkDeleted()
{
// Arrange
_hairStyleLinksContext = _db.SeedHairStyleLinksContext();
ulong id = 2;
List <HairStyleLinks> currentHairStyleLinks = _db.HairStyleLinks;
int currentHairStyleLinksCount = _db.HairStyleLinks.Count;
HairStyleLinks expected = _db.HairStyleLinks.FirstOrDefault(u => u.Id == id);
// Act
HairStyleLinks actual = await _hairStyleLinksContext.Delete(id);
int updatedHairStyleLinksCount = _db.HairStyleLinks.Count;
_db.HairStyleLinks = new List <HairStyleLinks>(currentHairStyleLinks);
// Assert
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(currentHairStyleLinksCount - 1, updatedHairStyleLinksCount);
}
public async Task <IActionResult> PutHairStyleLinks(ulong id, [FromBody] HairStyleLinks hairStyleLinks)
{
if (!_authorizationService.ValidateJWTToken(Request))
{
return(Unauthorized(new { errors = new { Token = new string[] { "Invalid token" } }, status = 401 }));
}
if (id != hairStyleLinks.Id)
{
return(BadRequest(new { errors = new { Id = new string[] { "ID sent does not match the one in the endpoint" } }, status = 400 }));
}
var correspondingHairStyle = await _context.HairStyles.FirstOrDefaultAsync(h => h.Id == hairStyleLinks.HairStyleId);
if (correspondingHairStyle == null)
{
return(NotFound(new { errors = new { HairStyleId = new string[] { "No matching hair style entry was found" } }, status = 404 }));
}
HairStyleLinks hsl = await _context.HairStyleLinks.FindAsync(id);
try
{
if (hsl != null)
{
hsl.LinkName = hairStyleLinks.LinkName;
hsl.LinkUrl = hairStyleLinks.LinkUrl;
hsl.HairStyleId = hairStyleLinks.HairStyleId;
_context.Entry(hsl).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok());
}
return(NotFound());
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(500));
}
}
public async Task <IActionResult> PutHairStyleLinks(ulong id, [FromBody] HairStyleLinks hairStyleLinks)
{
if (!_authorizationService.ValidateJWTCookie(Request))
{
return(Unauthorized(new { errors = new { Token = new string[] { "Invalid token" } }, status = 401 }));
}
if (id != hairStyleLinks.Id)
{
return(BadRequest(new { errors = new { Id = new string[] { "ID sent does not match the one in the endpoint" } }, status = 400 }));
}
var correspondingHairStyle = await _context.HairStyles.FirstOrDefaultAsync(h => h.Id == hairStyleLinks.HairStyleId);
if (correspondingHairStyle == null)
{
return(NotFound(new { errors = new { HairStyleId = new string[] { "No matching hair style entry was found" } }, status = 404 }));
}
_context.Entry(hairStyleLinks).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HairStyleLinksExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
