public void DeleteTest()
{
//Arrange
db = new touch_for_foodEntities();
TableOM target = new TableOM(db);
int expected = 3;
int actual;
table t = db.tables.Find(table1.id);
//Check Setup
Assert.IsNotNull(db.tables.Find(table1.id));
Assert.IsNotNull(db.orders.Find(order1.id).table_id);
Assert.IsNotNull(db.service_request.Find(serviceRequest1.id).table_id);
//Act
actual = target.delete(table1.id);
//Assert
db = new touch_for_foodEntities();
Assert.IsNull(db.tables.Find(table1.id));
Assert.IsNull(db.orders.Find(order1.id).table_id);
Assert.IsNull(db.service_request.Find(serviceRequest1.id).table_id);
Assert.AreEqual(expected, actual);
}
/**
* Filters the categories and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static order getOpenOrder(user usr)
{
touch_for_foodEntities db = new touch_for_foodEntities();
order o;
var models = db.orders
.Where(p => p.order_status == (int)OrderStatusHelper.OrderStatusEnum.PLACED || p.order_status == (int)OrderStatusHelper.OrderStatusEnum.EDITING || p.order_status == (int)OrderStatusHelper.OrderStatusEnum.PROCESSING)
.Where(p=>p.user_id == usr.id)
.OrderByDescending(p=>p.timestamp)
.ToList()
.Select(item =>
new order
{
id = item.id,
timestamp = item.timestamp,
total = item.total,
order_status = item.order_status,
order_item = item.order_item,
user = item.user,
table = item.table
}).AsQueryable();
if (models.Any())
{
o = models.ToArray()[0];
return o;
}
return null;
}
/**
* Filters the sides and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static IList<side> FilterListBySide(menu_category menu_category)
{
touch_for_foodEntities db = new touch_for_foodEntities();
List<side> filteredList = new List<side>();
int resto_id = menu_category.menu.resto_id;
// We want all sides that do not exist in this menu_category and that belong to this restaurant.
// is_deleted and is_active need to be considered too. Show only sides where is_active is false
// if side is_deleted is true, then there should be another page to revert that. the side functionality
// I'm putting should only set a side to is_active is true or false
List<side> restaurantSides = db.sides.Where
(
si =>
si.menu_category.menu.resto_id == resto_id
&& si.is_active == false
&& si.is_deleted == false
).ToList();
foreach (var side in restaurantSides)
{
if (side.menu_category_id.Equals(menu_category.id))
{
filteredList.Add(side);
}
}
db.Dispose();
return filteredList;
}
public static void MyClassCleanup()
{
touch_for_foodEntities db = new touch_for_foodEntities();
review r = db.reviews.Find(m_review.id);
db.reviews.Remove(r);
db.SaveChanges();
db.Dispose();
}
public void CreatePartialTest()
{
//Arrange
db = new touch_for_foodEntities();
PartialViewResult actual;
//Act
actual = (PartialViewResult)target.CreatePartial(menu1.id);
//Assert
Assert.AreEqual("_CategoryCreate", actual.ViewName);
}
public static void MyClassInitialize(TestContext testContext)
{
touch_for_foodEntities db = new touch_for_foodEntities();
m_review = new review();
m_review.restaurant_id = db.restaurants.First().id;
m_review.rating = 1;
m_review.is_anonymous = true;
db.reviews.Add(m_review);
db.SaveChanges();
db.Dispose();
}
public static user getAuthenticatedUser(HttpContextBase httpContext)
{
try
{
db = new touch_for_foodEntities();
String username = httpContext.User.Identity.Name;
return db.users.FirstOrDefault(m => m.username.Equals(username, StringComparison.Ordinal));
}
catch (Exception)
{
return null;
}
}
public static void MyClassInitialize(TestContext testContext)
{
//Add test data (order specific)
testDatabase = new TestDatabaseHelper();
restaurant1 = testDatabase.AddRestaurant();
table1 = testDatabase.AddTable(restaurant1);
user1 = testDatabase.AddUser("*****@*****.**", table1, (int)SiteRoles.Admin);
//Session
db = new touch_for_foodEntities();
target = new HomeController();
Session session = new Session(db, target);
session.simulateLogin(user1.username, user1.password);
}
public void AssignTest()
{
//Arrange
Util.Security.AES aes = new Util.Security.AES();
string encryption = aes.EncryptToString(table1.id.ToString());
//Act
RedirectToRouteResult actual = (RedirectToRouteResult)target.Assign(encryption);
//Assert
db = new touch_for_foodEntities();
Assert.AreEqual("Menu", actual.RouteValues["controller"]);
Assert.AreEqual("UserMenu", actual.RouteValues["action"]);
Assert.AreEqual(table1.id , db.users.Find(user1.id).current_table_id);
}
/// <summary>
/// Creates an entry of type item in the database.
/// </summary>
/// <returns>The created item entry.</returns>
public item AddItem()
{
//Initialise
db = new touch_for_foodEntities();
item testItem = new item();
//Set Attributes
testItem.name = "UnitTest";
//Save
db.items.Add(testItem);
db.SaveChanges();
db.Dispose();
return testItem;
}
public void CancelConfirmedServiceRequestLockErrorTest()
{
//Check Setup
db = new touch_for_foodEntities();
Assert.IsTrue(db.service_request.Find(request1.id).status == (int)ServiceRequestUtil.ServiceRequestStatus.OPEN);
//Arrange
request1.version++;
//Act
target.CancelConfirmed(request1);
//Assert
db = new touch_for_foodEntities();
Assert.IsTrue(db.service_request.Find(request1.id).status == (int)ServiceRequestUtil.ServiceRequestStatus.OPEN);
}
public void DeleteItemActiveExceptionTest()
{
//Arrange
db = new touch_for_foodEntities();
MenuItemOM target = new MenuItemOM(db);
menuItem1.is_active = true;
db.Entry(menuItem1).State = EntityState.Modified;
db.SaveChanges();
//Act
int actual = target.delete(menuItem1.id);
//Assert
db = new touch_for_foodEntities();
Assert.IsFalse(db.menu_item.Find(menuItem1.id).is_deleted);
Assert.IsNotNull(db.order_item.Find(orderItem1.id));
}
/// <summary>
/// Creates a friendship entity
/// </summary>
/// <param name="user1">The first user in the friendship</param>
/// <param name="user2">The second user in the friendship</param>
/// <returns>the created friendship entity</returns>
public friendship AddFriendship(user user1, user user2)
{
//Initialise
db = new touch_for_foodEntities();
friendship testFriendship = new friendship();
//Set Attributes
testFriendship.first_user = user1.id;
testFriendship.second_user = user2.id;
//Save
db.friendships.Add(testFriendship);
db.SaveChanges();
db.Dispose();
return testFriendship;
}
/// <summary>
/// Adds a category entry to the database
/// </summary>
/// <returns>The created category entity.</returns>
public category AddCategory()
{
//Initialise
db = new touch_for_foodEntities();
category testCategory = new category();
//Set attributes
testCategory.name = "UnitTest";
testCategory.version = 0;
//Save
db.categories.Add(testCategory);
db.SaveChanges();
db.Dispose();
return testCategory;
}
public void CreateTest()
{
// Arrange
db = new touch_for_foodEntities();
RestaurantUserController target = new RestaurantUserController();
int numExpectedAssociations = db.restaurant_user.ToList<restaurant_user>().Count() + 1;
// Act
var actualResult = target.Create(restoUser2) as RedirectToRouteResult;
// Assertions
db = new touch_for_foodEntities();
var actualResultURI = actualResult.RouteValues["action"];
int actualRestoUsers = db.restaurant_user.ToList<restaurant_user>().Count();
Assert.AreEqual(numExpectedAssociations, actualRestoUsers);
Assert.AreEqual("Index", actualResultURI);
}
public static user getAuthenticatedUser(HttpRequestBase requestBase)
{
try
{
db = new touch_for_foodEntities();
HttpCookie formsCookie = requestBase.Cookies[FormsAuthentication.FormsCookieName];
FormsAuthenticationTicket auth = FormsAuthentication.Decrypt(formsCookie.Value);
int userID = int.Parse(auth.UserData);
UserIM im = new UserIM();
return im.find(userID);
}
catch (Exception)
{
return null;
}
}
public void DeleteItemActiveExceptionTest()
{
//Arrange
db = new touch_for_foodEntities();
OrderOM target = new OrderOM(db);
orderItem1.order_item_status = (int)OrderStatusHelper.OrderItemStatusEnum.PROCESSING;
db.Entry(orderItem1).State = EntityState.Modified;
db.SaveChanges();
//Act
int actual = target.delete(order1.id);
//Assert
db = new touch_for_foodEntities();
Assert.IsFalse(db.orders.Find(order1.id).order_status ==
(int)OrderStatusHelper.OrderStatusEnum.DELETED);
Assert.IsFalse(db.order_item.Find(orderItem1.id).order_item_status ==
(int)OrderStatusHelper.OrderItemStatusEnum.DELETED);
}
// Should be able to search:
// Item:
// - name, description, metadata
// Category:
// - name
// Menu:
// - name
public static IList<menu_item> GetAll(int restoId)
{
using (var db = new touch_for_foodEntities())
{
return db.menu_item
.Include(x => x.item)
.Include(x => x.menu_category.category)
.Include(x => x.menu_category.menu)
.Where
(
x => x.is_active == true &&
x.is_deleted == false &&
x.menu_category.is_active == true &&
x.menu_category.is_deleted == false &&
x.menu_category.menu.resto_id == restoId &&
x.menu_category.menu.is_active == true &&
x.menu_category.menu.is_deleted == false
).ToList();
}
}
public void CreateUserDBEntityValidationExceptionTest()
{
//Arrange
db = new touch_for_foodEntities();
UserController target = new UserController();
user2.email = null;
user2.username = null;
int expectedUsers = db.users.ToList<user>().Count();
Session session = new Session(db, target);
var actual = target.Create(user2) as ViewResult;
// Assert
db = new touch_for_foodEntities();
int actualUsers = db.users.ToList<user>().Count();
string errorMsg = actual.ViewBag.Error;
Assert.IsNotNull(errorMsg); //error message is sent to view
Assert.AreEqual(expectedUsers, actualUsers);
Assert.AreEqual("Create", actual.ViewName); //Directed to correct location
}
public void CreateExceptionTest()
{
//Arrange
db = new touch_for_foodEntities();
target = new RestaurantController(); //reset target creating exception.
int numberOfRestaurantsBefore = db.restaurants.ToList<restaurant>().Count();
//Act
ViewResult actual = target.Create(restaurant2) as ViewResult;
//Assert
db = new touch_for_foodEntities();
int numberOfRestaurantsAfter = db.restaurants.ToList<restaurant>().Count();
List<restaurant_user> restaurantUsers = db.restaurant_user
.Where(ru => (ru.restaurant_id == restaurant2.id) &&
(ru.user_id == user1.id)).ToList<restaurant_user>();
string errorMsg = actual.ViewBag.Error;
Assert.AreEqual(numberOfRestaurantsBefore, numberOfRestaurantsAfter); //no restaurants are created
Assert.IsTrue(restaurantUsers.Count() == 0); //no restaurant_user are created
Assert.IsNotNull(errorMsg); //error message is sent to view
}
public static void MyClassInitialize(TestContext testContext)
{
//Add test data (order specific)
testDatabase = new TestDatabaseHelper();
restaurant1 = testDatabase.AddRestaurant();
table1 = testDatabase.AddTable(restaurant1);
user1 = testDatabase.AddUser("*****@*****.**", table1, (int)SiteRoles.Customer);
order1 = testDatabase.AddOrder(table1);
item1 = testDatabase.AddItem();
category1 = testDatabase.AddCategory();
menu1 = testDatabase.AddMenu(restaurant1);
menuCategory1 = testDatabase.AddMenuCategory(category1, menu1);
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
orderItem1 = testDatabase.AddOrderItem(order1, menuItem1);
//Session
db = new touch_for_foodEntities();
ReviewController target = new ReviewController();
Session session = new Session(db, target);
session.simulateLogin(user1.username, user1.password);
}
/**
* Filters the categories and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static IList<item> filterListByItem(menu_category menu_category,touch_for_foodEntities db)
{
List<item> filteredList = new List<item>();
MenuItemIM im = new MenuItemIM(db);
int resto_id = menu_category.menu.resto_id;
bool reject = false;
foreach (item i in db.items.ToList())
{
reject = false;
//First check that the category does belong to the restaurant
//Find all usages of the category in question in the current restaurant
List<menu_item> usages = db.menu_item.Where(mi => mi.item_id == i.id && mi.menu_category.menu.resto_id == resto_id).ToList();
//If it was never used by this restaurant, then the restaurant could not have created it
// because create automatically adds the created item to the menu
if (usages.Count == 0)
{
reject = true;
}
if (menu_category.category.id == i.category_id)
{
foreach (menu_item m_i in im.find(false, menu_category.id))
{
if (i.id == m_i.item_id)
{
reject = true;
break;
}
}
if (!reject)
{
filteredList.Add(i);
}
}
}
db.Dispose();
return filteredList;
}
/**
* Filters the categories and only returns those that are not already assigned to the menu
* that is passed in.
* */
public static IList<category> filterListByMenu(menu menu,touch_for_foodEntities db)
{
List<category> filteredList = new List<category>();
MenuCategoryIM im = new MenuCategoryIM(db);
CategoryIM cim = new CategoryIM(db);
int resto_id = menu.resto_id;
bool reject = false;
foreach (category cat in cim.find().ToList())
{
reject = false;
//First check that the category does belong to the restaurant
//Find all usages of the category in question in the current restaurant
List<menu_category> usages = db.menu_category.Where(mc => mc.category_id == cat.id && mc.menu.resto_id == resto_id).ToList();
//If it was never used by this restaurant, then the restaurant could not have created it
// because create automatically adds the created item to the menu
if (usages.Count == 0)
{
reject = true;
}
//Check if the category is being used buy the current menu
foreach (menu_category menu_cat in im.find(false, menu.id))
{
if (cat.id == menu_cat.category_id)
{
reject = true;
break;
}
}
if (!reject)
{
filteredList.Add(cat);
}
}
return filteredList;
}
public void DeleteTest()
{
//Arrange
db = new touch_for_foodEntities();
WaiterOM target = new WaiterOM(db);
int expected = 2;
int actual;
table t = db.tables.Find(table1.id);
//Check Setup
Assert.IsNotNull(db.waiters.Find(waiter1.id));
Assert.IsNotNull(db.orders.Find(order1.id).waiter_id);
//Act
actual = target.delete(waiter1.id);
//Assert
db = new touch_for_foodEntities();
Assert.IsNull(db.waiters.Find(waiter1.id));
Assert.IsNull(db.orders.Find(order1.id).waiter_id);
Assert.AreEqual(expected, actual);
}
public void AddCategoryTest()
{
//Arrange
db = new touch_for_foodEntities();
int numberOfMenuCategoriesBefore = db.categories.Find(category1.id).menu_category
.ToList<menu_category>().Count();
//Act
target.AddCategory(menu1.id, category1.id);
//Assert
db = new touch_for_foodEntities();
int numberOfMenuCategoriesAfter = db.categories.Find(category1.id).menu_category
.ToList<menu_category>().Count();
//only one menu category added
Assert.AreEqual((numberOfMenuCategoriesBefore + 1), numberOfMenuCategoriesAfter);
//each menu category has the right menu and category attributes.
foreach (menu_category mc in db.categories.Find(category1.id).menu_category.ToList<menu_category>())
{
Assert.IsTrue(mc.menu_id == menu1.id);
}
}
public void OnTheMenuTest()
{
//Arrange
db = new touch_for_foodEntities();
Menu_ItemController target = new Menu_ItemController();
List<menu_item> expectedMenuItems = db.menu_item.Where(mi => mi.menu_category_id == menuCategory1.id && mi.is_deleted == false).ToList();
PartialViewResult actual;
//Act
actual = (PartialViewResult)target.OnTheMenu(menuCategory1.id);
//Assert
List<menu_item> actualMenuItems = actual.Model as List<menu_item>;
Assert.AreEqual(expectedMenuItems.Count(), actualMenuItems.Count());
Assert.AreEqual("_OnTheMenu", actual.ViewName);
}
public void MyTestInitialize()
{
//Add test data (order specific)
db = new touch_for_foodEntities();
menuItem1 = testDatabase.AddMenuItem(item1, menuCategory1);
orderItem1 = testDatabase.AddOrderItem(order1, menuItem1);
reviewOrderItem1 = testDatabase.AddReviewOrderItem(review1, orderItem1, "testing1", 2);
reviewOrderItem2 = testDatabase.AddReviewOrderItem(review1, orderItem1, "testing2", 3);
//set parameters for menuItem2
menuItem2 = new menu_item();
menuItem2.item_id = item1.id;
menuItem2.menu_category_id = menuCategory1.id;
menuItem2.price = new decimal(10.99);
menuItem2.is_active = false;
menuItem2.is_deleted = false;
}
public void IndexTest()
{
//Arrange
db = new touch_for_foodEntities();
Menu_ItemController target = new Menu_ItemController();
List<menu_item> expectedMenuItems = db.menu_item.Where(mi => mi.is_active == true && mi.is_deleted == false).ToList();
ViewResult actual;
//Act
actual = (ViewResult)target.Index();
//Assert
List<menu_item> actualMenuItems = actual.Model as List<menu_item>;
Assert.AreEqual(expectedMenuItems.Count(), actualMenuItems.Count());
}
public void GetAllReviewsTest()
{
//Arrange
db = new touch_for_foodEntities();
Menu_ItemController target = new Menu_ItemController();
PartialViewResult actual;
List<review_order_item> expectedReviews = db.menu_item.Find(menuItem1.id)
.order_item
.SelectMany(oi => oi.review_order_item)
.OrderByDescending(r => r.submitted_on)
.ToList<review_order_item>();
//Act
actual = target.GetAllReviews(menuItem1);
//Assert
List<review_order_item> actualReviews = actual.Model as List<review_order_item>;
Assert.AreEqual(expectedReviews.Count(), actualReviews.Count());
Assert.AreEqual("_PastReviewsPartial", actual.ViewName);
}
public void EditViewTest()
{
// Arrange
db = new touch_for_foodEntities();
Menu_ItemController target = new Menu_ItemController();
int expected = menuItem1.id;
SelectList expectedItemList = new SelectList(db.items, "id", "name", menuItem1.item_id);
SelectList expectedCategoryList = new SelectList(db.menu_category, "id", "id", menuItem1.menu_category_id);
ViewResult actual;
// Act
actual = (ViewResult)target.Edit(menuItem1.id);
// Assert
Assert.AreEqual(expected, ((menu_item)actual.ViewData.Model).id);
SelectList actualItemList = actual.ViewBag.item_id;
Assert.AreEqual(expectedItemList.GetType(), actualItemList.GetType());
Assert.AreEqual(expectedItemList.Count(), actualItemList.Count());
SelectList actualCategoryList = actual.ViewBag.menu_category_id;
Assert.AreEqual(expectedCategoryList.GetType(), actualCategoryList.GetType());
Assert.AreEqual(expectedCategoryList.Count(), actualCategoryList.Count());
}
