public async Task GetAsync_ReturnsUserLunches()
{
var userId = "09123091823";
var userLunch1 = GetUserLunch(Guid.NewGuid(), Guid.NewGuid(), userId);
var userLunch2 = GetUserLunch(Guid.NewGuid(), Guid.NewGuid(), userId);
var userLunch3 = GetUserLunch();
var dbOptions = GetDbOptions("GetAsync_ReturnsLunches");
using (var context = new MSLunchesContext(dbOptions))
{
await context.UserLunches.AddAsync(userLunch1);
await context.UserLunches.AddAsync(userLunch2);
await context.UserLunches.AddAsync(userLunch3);
await context.SaveChangesAsync();
}
IEnumerable <UserLunch> result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new UserLunchService(context);
result = await classUnderTest.GetAsync(userId);
}
Assert.NotNull(result);
Assert.Contains(result, lunch => Equals(lunch, userLunch1));
Assert.Contains(result, lunch => Equals(lunch, userLunch2));
Assert.DoesNotContain(result, lunch => Equals(lunch, userLunch3));
}
public async void CreateAsync_ReturnsCreatedLunch()
{
var lunchId = Guid.NewGuid();
using (var context = new MSLunchesContext(GetDbOptions("CreateAsync_ReturnsCreatedLunch")))
{
context.Lunches.Add(GetLunch(lunchId));
context.SaveChanges();
}
var lunch = GetUserLunch(lunchId: lunchId);
UserLunch result = null;
using (var context = new MSLunchesContext(GetDbOptions("CreateAsync_ReturnsCreatedLunch")))
{
var classUnderTest = new UserLunchService(context);
result = await classUnderTest.CreateAsync(lunch);
}
Assert.NotNull(result);
Assert.NotEqual(Guid.Empty, result.Id);
Assert.NotEqual(default(DateTime), result.CreatedOn);
Assert.Equal(lunch.Approved, result.Approved);
Assert.Equal(lunch.LunchId, result.LunchId);
Assert.Equal(lunch.UserId, result.UserId);
}
public async void UpdateAsync_ReturnsLunchModified_WhenIdExist()
{
var lunch = GetADefaultLunch();
var lunchModified = new Lunch
{
Id = lunch.Id,
Date = DateTime.Today.AddDays(-1),
MealId = Guid.NewGuid(),
UpdatedBy = "updater"
};
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsLunchModified_WhenIdExist")))
{
await context.Lunches.AddAsync(lunch);
await context.SaveChangesAsync();
}
Lunch result = null;
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsLunchModified_WhenIdExist")))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.UpdateAsync(lunchModified);
}
Assert.NotNull(result);
Assert.Equal(lunchModified.Id, result.Id);
Assert.NotEqual(lunchModified.UpdatedOn, result.UpdatedOn);
Assert.Equal(lunchModified.UpdatedBy, result.UpdatedBy);
Assert.Equal(lunchModified.MealId, result.MealId);
Assert.Equal(lunchModified.Date, result.Date);
}
public async Task GetAsync_ReturnsMeals()
{
var meal1 = GetADefaultMeal(Guid.NewGuid());
var meal2 = GetADefaultMeal(Guid.NewGuid());
var dbOptions = GetDbOptions("GetAsync_ReturnsMeals");
using (var context = new MSLunchesContext(dbOptions))
{
context.MealTypes.Add(GetSampleMealType());
context.Meals.Add(meal1);
context.Meals.Add(meal2);
context.SaveChanges();
}
IEnumerable <Meal> result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new MealService(context);
result = await classUnderTest.GetAsync();
}
Assert.NotNull(result);
Assert.Contains(result, meal => Equals(meal, meal1));
Assert.Contains(result, meal => Equals(meal, meal2));
}
public async void UpdateAsync_ReturnsMealModified_WhenIdExist()
{
var meal = GetADefaultMeal();
var mealModified = new Meal
{
Id = meal.Id,
Name = "newName",
TypeId = meal.TypeId + 1,
UpdatedBy = "updater"
};
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsMealModified_WhenIdExist")))
{
await context.Meals.AddAsync(meal);
await context.SaveChangesAsync();
}
Meal result = null;
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsMealModified_WhenIdExist")))
{
var classUnderTest = new MealService(context);
result = await classUnderTest.UpdateAsync(mealModified);
}
Assert.NotNull(result);
Assert.Equal(mealModified.Id, result.Id);
Assert.NotEqual(mealModified.UpdatedOn, result.UpdatedOn);
Assert.Equal(mealModified.UpdatedBy, result.UpdatedBy);
Assert.Equal(mealModified.TypeId, result.TypeId);
Assert.Equal(mealModified.Name, result.Name);
}
public async Task DeleteByIdAsync_ReturnsZero_WhenIdNotExist()
{
var result = 0;
using (var context = new MSLunchesContext(GetDbOptions("DeleteByIdAsync_ReturnsCountOfChanges_WhenIdExist")))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.DeleteByIdAsync(Guid.NewGuid());
}
Assert.True(result == 0);
}
public async void UpdateAsync_ReturnsNull_WhenIdNotExist()
{
var lunchModified = GetADefaultLunch();
Lunch result = null;
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsNull_WhenIdNotExist")))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.UpdateAsync(lunchModified);
}
Assert.Null(result);
}
public async void CreateAsync_ReturnsCreatedLunch()
{
var lunch = GetADefaultLunch();
Lunch result = null;
using (var context = new MSLunchesContext(GetDbOptions("CreateAsync_ReturnsCreatedLunch")))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.CreateAsync(lunch);
}
Assert.NotNull(result);
Assert.NotEqual(Guid.Empty, result.Id);
Assert.NotEqual(default(DateTime), result.CreatedOn);
Assert.Equal(lunch.MealId, result.MealId);
Assert.Equal(lunch.Date, result.Date);
}
public async void CreateAsync_ReturnsCreatedMeal()
{
var meal = GetADefaultMeal();
Meal result = null;
using (var context = new MSLunchesContext(GetDbOptions("CreateAsync_ReturnsCreatedMeal")))
{
var classUnderTest = new MealService(context);
result = await classUnderTest.CreateAsync(meal);
}
Assert.NotNull(result);
Assert.NotEqual(Guid.Empty, result.Id);
Assert.NotEqual(default(DateTime), result.CreatedOn);
Assert.Equal(meal.TypeId, result.TypeId);
Assert.Equal(meal.Name, result.Name);
}
public async Task GetByIdAsync_ReturnsNull_WhenIdNotExist()
{
var dbOptions = GetDbOptions("GetByIdAsync_ReturnsLunch_WhenIdExist");
using (var context = new MSLunchesContext(dbOptions))
{
context.Lunches.Add(GetADefaultLunch());
context.SaveChanges();
}
Lunch result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.GetByIdAsync(Guid.NewGuid());
}
Assert.Null(result);
}
public async Task GetById_RetunsAMealType()
{
var mealType = GetSampleMealType(1);
using (var context = new MSLunchesContext(GetDbOptions("GetById_RetunsAMealType")))
{
context.MealTypes.Add(mealType);
context.SaveChanges();
}
MealType result;
using (var context = new MSLunchesContext(GetDbOptions("GetById_RetunsAMealType")))
{
var classUnderTest = new MealTypeService(context);
result = await classUnderTest.GetByIdAsync(mealType.Id);
}
Assert.Equal(mealType.Id, result.Id);
}
public async Task GetAsync_ReturnsLunches()
{
var mealType = new MealType
{
Id = 1,
Description = "desc",
IsSelectable = true
};
var meal = GetADefaultMeal(Guid.NewGuid(), mealType.Id);
var lunch1 = GetADefaultLunch(Guid.NewGuid(), meal.Id);
var lunch2 = GetADefaultLunch(Guid.NewGuid(), meal.Id);
var dbOptions = GetDbOptions("GetAsync_ReturnsLunches");
using (var context = new MSLunchesContext(dbOptions))
{
await context.MealTypes.AddAsync(mealType);
await context.Meals.AddAsync(meal);
await context.Lunches.AddAsync(lunch1);
await context.Lunches.AddAsync(lunch2);
await context.SaveChangesAsync();
}
IEnumerable <Lunch> result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.GetAsync();
}
Assert.NotNull(result);
Assert.Contains(result, lunch => Equals(lunch, lunch1));
Assert.Contains(result, lunch => Equals(lunch, lunch2));
}
public async Task DeleteByIdAsync_ReturnsCountOfChanges_WhenIdExist()
{
var lunch = GetADefaultLunch();
using (var context = new MSLunchesContext(GetDbOptions("DeleteByIdAsync_ReturnsCountOfChanges_WhenIdExist")))
{
await context.Lunches.AddAsync(lunch);
await context.SaveChangesAsync();
}
var result = 0;
using (var context = new MSLunchesContext(GetDbOptions("DeleteByIdAsync_ReturnsCountOfChanges_WhenIdExist")))
{
var classUnderTest = new LunchService(context);
result = await classUnderTest.DeleteByIdAsync(lunch.Id);
}
Assert.True(result > 0);
}
public async Task DeleteByIdAsync_ThrowsNotFoundException_WhenIdNotExist()
{
Exception exception = null;
using (var context = new MSLunchesContext(GetDbOptions("DeleteByIdAsync_ThrowsNotFoundException_WhenIdNotExist")))
{
var classUnderTest = new UserLunchService(context);
try
{
await classUnderTest.DeleteByIdAsync(Guid.NewGuid());
}
catch (Exception ex)
{
exception = ex;
}
}
var result = Assert.IsType <NotFoundException>(exception);
Assert.False(string.IsNullOrEmpty(result.Message));
}
public async void UpdateAsync_ReturnsNull_WhenIdNotExist()
{
var lunchModified = GetUserLunch();
Exception exception = null;
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsNull_WhenIdNotExist")))
{
var classUnderTest = new UserLunchService(context);
try
{
await classUnderTest.UpdateAsync(lunchModified);
}
catch (Exception ex)
{
exception = ex;
}
}
var notFoundException = Assert.IsType <NotFoundException>(exception);
Assert.False(string.IsNullOrEmpty(notFoundException.Message));
}
public async void UpdateAsync_ReturnsLunchModified_WhenIdExist()
{
var lunchId = Guid.NewGuid();
var userLunch = GetUserLunch();
var userLunchModified = new UserLunch
{
Id = userLunch.Id,
Approved = !userLunch.Approved,
LunchId = lunchId,
UserId = "newUserId1",
UpdatedBy = "updater"
};
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsLunchModified_WhenIdExist")))
{
await context.Lunches.AddAsync(GetLunch(lunchId));
await context.UserLunches.AddAsync(userLunch);
await context.SaveChangesAsync();
}
UserLunch result = null;
using (var context = new MSLunchesContext(GetDbOptions("UpdateAsync_ReturnsLunchModified_WhenIdExist")))
{
var classUnderTest = new UserLunchService(context);
result = await classUnderTest.UpdateAsync(userLunchModified);
}
Assert.NotNull(result);
Assert.Equal(userLunchModified.Id, result.Id);
Assert.NotEqual(userLunchModified.UpdatedOn, result.UpdatedOn);
Assert.Equal(userLunchModified.UpdatedBy, result.UpdatedBy);
Assert.Equal(userLunchModified.Approved, result.Approved);
Assert.Equal(userLunchModified.UserId, result.UserId);
Assert.Equal(userLunchModified.LunchId, result.LunchId);
}
public async Task GetByIdAsync_ReturnsMeal_WhenIdExist()
{
var meal = GetADefaultMeal(Guid.NewGuid());
var dbOptions = GetDbOptions("GetByIdAsync_ReturnsMeal_WhenIdExist");
using (var context = new MSLunchesContext(dbOptions))
{
context.Meals.Add(meal);
context.SaveChanges();
}
Meal result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new MealService(context);
result = await classUnderTest.GetByIdAsync(meal.Id);
}
Assert.NotNull(result);
Assert.True(Equals(meal, result));
}
public async Task GetByIdAsync_ReturnsLunch_WhenIdExist()
{
var userLunch = GetUserLunch(Guid.NewGuid());
var dbOptions = GetDbOptions("GetByIdAsync_ReturnsLunch_WhenIdExist");
using (var context = new MSLunchesContext(dbOptions))
{
context.UserLunches.Add(userLunch);
context.SaveChanges();
}
UserLunch result = null;
using (var context = new MSLunchesContext(dbOptions))
{
var classUnderTest = new UserLunchService(context);
result = await classUnderTest.GetByIdAsync(userLunch.Id);
}
Assert.NotNull(result);
Assert.True(Equals(userLunch, result));
}
public async Task Get_ReturnsAListOfMealTypes()
{
var mealType1 = GetSampleMealType(1);
var mealType2 = GetSampleMealType(2);
using (var context = new MSLunchesContext(GetDbOptions("Get_ReturnsAListOfMealTypes")))
{
context.MealTypes.Add(mealType1);
context.MealTypes.Add(mealType2);
context.Meals.Add(GetSampleMeal(1));
context.SaveChanges();
}
IEnumerable <MealType> result;
using (var context = new MSLunchesContext(GetDbOptions("Get_ReturnsAListOfMealTypes")))
{
var classUnderTest = new MealTypeService(context);
result = await classUnderTest.GetAsync();
}
Assert.Contains(result, a => a.Id == mealType1.Id);
Assert.Contains(result, a => a.Id == mealType2.Id);
}
/// <summary>
/// Initializes a new instance of the <see cref="MealService"/> class.
/// </summary>
/// <param name="dbContext"><see cref="MSLunchesContext"/> instance required to access database </param>
public MealService(MSLunchesContext dbContext)
{
_dbContext = dbContext;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, MSLunchesContext dbContext)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseMiddleware(typeof(ErrorHandlingMiddleware));
app.UseMiddleware(typeof(AuthorizationMiddleware));
//Enable swagger midleware
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.), specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
//Sets swagger UI route on root, "GET {baseUrl}/ "
c.RoutePrefix = string.Empty;
c.SwaggerEndpoint("/swagger/v1/swagger.json", "WebApiCoreMSLunches V1");
});
//TODO : Add a list of supported origins on a config
app.UseCors("AllowAllOrigins");
app.UseAuthentication();
app.UseMvc();
DatabaseMSLunches.Initialize(dbContext);
}
/// <summary>
/// Initializes a new instance of the <see cref="UserLunchService"/> class.
/// </summary>
/// <param name="dbContext"><see cref="MSLunchesContext"/> instance required to access database </param>
public UserLunchService(MSLunchesContext dbContext)
{
_dbContext = dbContext;
}
