public async void LunchService_GetRestaurantsAsync_ReturnsRestaurantDtos()
{
// arrange
Mock <IGetLunchOptions> mockOptions = new Mock <IGetLunchOptions>();
Mock <IRepository> mockRepo = new Mock <IRepository>();
Mock <IChaos> mockRandom = new Mock <IChaos>();
Mock <IRestaurantCache> mockCache = new Mock <IRestaurantCache>();
LunchService target = new LunchService(mockOptions.Object, mockRepo.Object, mockRandom.Object, mockCache.Object);
mockOptions.Setup(x => x.GetAllRestaurantsInZipAsync(It.IsAny <string>())).ReturnsAsync(new List <RestaurantDto> {
new RestaurantDto {
Name = "Bob's Burgers",
},
new RestaurantDto {
Name = "Jimmy Pesto's Pizzaria",
},
});
string zip = "38655";
// act
var result = await target.GetRestaurantsAsync(zip);
// assert
Assert.Equal(2, result.Count());
}
/// <summary>
/// (Required) Entry method of your Lambda function.
/// </summary>
/// <param name="lambdaEvent">Type returned from CodeMash</param>
/// <param name="context">Context data of a function (function config)</param>
/// <returns></returns>
public async Task <APIGatewayProxyResponse> Handler(CustomEventRequest <BasicInput> lambdaEvent, ILambdaContext context)
{
// - Get environment variable
var divisionId = Environment.GetEnvironmentVariable("division");
var division = new Division {
Id = divisionId
};
var lunchService = new LunchService
{
HrService = new HrService
{
EmployeesRepository = new EmployeesRepository()
},
MenuRepository = new MenuRepository()
};
var menu = await lunchService.CreateBlankMenu(division);
var body = new Dictionary <string, string>
{
{ "menu", menu.Id }
};
return(new APIGatewayProxyResponse
{
Body = JsonConvert.SerializeObject(body),
StatusCode = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
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 void Employee_ElevatorSwipeTest_ShouldPrintToConsole()
{
var xService = new LunchService();
_employeeElevator = new Employee(xService);
_employeeElevator.SwipeCard();
}
public HomeController(ILogger <HomeController> logger, ILocationRepository locationRepository, LunchService lunchService, ILunchOrderRepository lunchOrderRepository)
{
_logger = logger;
_locationRepository = locationRepository;
_lunchOrderRepository = lunchOrderRepository;
_lunchService = lunchService;
}
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 Task <APIGatewayProxyResponse> Handler(CustomEventRequest <BasicInput> lambdaEvent, ILambdaContext context)
{
//var lunchDate = DateTime.Parse(Environment.GetEnvironmentVariable("lunchTime"));
// var menuID = Environment.GetEnvironmentVariable("menuID");
var lunchDate = DateTime.Parse("2020-02-09");
var menuID = "5e3c016f214efe00018721ab";
var service = new CodeMashRepository <MenuEntity>(Client);
var menuEntity = await service.FindOneByIdAsync(
menuID,
new DatabaseFindOneOptions()
);
var menu = new Menu(DateTime.Now, null, null)
{
Id = menuID,
Division = new Division()
{
Id = menuEntity.DivisionId
}
};
var lunchService = new LunchService()
{
HrService = new HrService()
{
EmployeesRepository = new EmployeesRepository()
},
MenuRepository = new MenuRepository(),
NotificationSender = new NotificationSender()
};
await lunchService.AdjustMenuLunchTime(lunchDate, menu, menuEntity.Employees);
var response = new
{
lambdaEvent,
};
return(new APIGatewayProxyResponse
{
Body = JsonConvert.SerializeObject(response),
StatusCode = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
public async Task GetValueAsync_CallsRepo()
{
var repo = new Mock <ILunchRepository>();
var logger = new Mock <IObjectLogger>();
repo.Setup(x => x.GetValueAsync(It.IsAny <int>())).Returns(Task.FromResult("some value"));
var service = new LunchService(repo.Object, logger.Object);
var result = await service.GetValueAsync(1);
repo.Verify(x => x.GetValueAsync(It.IsAny <int>()), Times.Exactly(1));
Assert.AreEqual(result, "some value");
}
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 Task GetIntValueAsync_CallsRepo()
{
var repo = new Mock <ILunchRepository>();
var logger = new Mock <IObjectLogger>();
repo.Setup(x => x.GetIntValueAsync()).Returns(Task.FromResult(12));
var service = new LunchService(repo.Object, logger.Object);
var result = await service.GetIntValueAsync();
repo.Verify(x => x.GetIntValueAsync(), Times.Exactly(1));
Assert.IsInstanceOfType(result, typeof(int));
Assert.AreEqual(result, 12);
}
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 LunchService_GetRestaurantAsync_FiltersOutNopes()
{
// arrange
Mock <IGetLunchOptions> mockOptions = new Mock <IGetLunchOptions>();
Mock <IRepository> mockRepo = new Mock <IRepository>();
Mock <IChaos> mockRandom = new Mock <IChaos>();
IRestaurantCache cache = new RestaurantCacheMock();
mockRandom.Setup(m => m.Next(It.IsAny <int>())).Returns(0);
Guid sessionGuid = Guid.NewGuid();
mockOptions.Setup(x => x.GetAvailableRestaurantOptionsAsync(sessionGuid, It.IsAny <SearchOptions>())).ReturnsAsync(new List <RestaurantDto> {
new RestaurantDto {
Name = "COok OOout",
Id = "rest3"
},
new RestaurantDto {
Name = "Jimmy Pesto's Pizzaria",
Id = "rest2"
},
new RestaurantDto {
Name = "Bob's Burgers",
Id = "rest1"
},
});
mockRepo.Setup(x => x.GetNopesAsync(It.IsAny <IEnumerable <int> >())).ReturnsAsync(new List <string> {
"rest2",
"rest3"
});
List <int> users = new List <int> {
1, 2
};
LunchService target = new LunchService(mockOptions.Object, mockRepo.Object, mockRandom.Object, cache);
// act
var result = await target.GetRestaurantAsync(sessionGuid, new SearchOptions()
{
UserIds = users
});
// assert
Assert.Equal("Bob's Burgers", 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 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 void LunchService_GetRestaurantAsync_ThrowTooManyRequestsWhenOutOfSuggestions()
{
Mock <IGetLunchOptions> mockOptions = new Mock <IGetLunchOptions>();
Mock <IRepository> mockRepo = new Mock <IRepository>();
Mock <IChaos> mockRandom = new Mock <IChaos>();
IRestaurantCache cache = new RestaurantCacheMock();
const string expected = "bob's burgers";
Guid sessionId = Guid.NewGuid();
mockOptions.Setup(x => x.GetAvailableRestaurantOptionsAsync(sessionId, It.IsAny <SearchOptions>())).ReturnsAsync(new List <RestaurantDto> {
new RestaurantDto {
Name = expected,
},
});
LunchService target = new LunchService(mockOptions.Object, mockRepo.Object, mockRandom.Object, cache);
// act
var result = await target.GetRestaurantAsync(sessionId, new SearchOptions());
// assert
await Assert.ThrowsAsync <TooManyRequestsException>(async() => await target.GetRestaurantAsync(sessionId, new SearchOptions()));
}
public async void LunchService_GetRestaurantAsync_ReturnsRestaurantDto()
{
// arrange
Mock <IGetLunchOptions> mockOptions = new Mock <IGetLunchOptions>();
Mock <IRepository> mockRepo = new Mock <IRepository>();
Mock <IChaos> mockRandom = new Mock <IChaos>();
Mock <IRestaurantCache> mockCache = new Mock <IRestaurantCache>();
LunchService target = new LunchService(mockOptions.Object, mockRepo.Object, mockRandom.Object, mockCache.Object);
const string expected = "bob's burgers";
Guid sessionId = Guid.NewGuid();
mockOptions.Setup(x => x.GetAvailableRestaurantOptionsAsync(sessionId, It.IsAny <SearchOptions>())).ReturnsAsync(new List <RestaurantDto> {
new RestaurantDto {
Name = expected,
},
});
// act
var result = await target.GetRestaurantAsync(sessionId, new SearchOptions());
// assert
Assert.Equal(expected, result.Name);
}
/// <summary>
/// (Required) Entry method of your Lambda function.
/// </summary>
/// <param name="lambdaEvent">Type returned from CodeMash</param>
/// <param name="context">Context data of a function (function config)</param>
/// <returns></returns>
public async Task <APIGatewayProxyResponse> Handler(CustomEventRequest <BasicInput> lambdaEvent, ILambdaContext context)
{
var menuRepo = new MenuRepository();
var menu = await menuRepo.GetClosestMenu();
var lunchService = new LunchService
{
MenuRepository = menuRepo,
NotificationSender = new NotificationSender()
};
var response = await lunchService.SendMessageAboutFoodOrder(menu);
return(new APIGatewayProxyResponse
{
Body = JsonConvert.SerializeObject(response),
StatusCode = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
public HomeController(LunchService service)
{
_service = service;
}
