public void Setup()
{
inMemoryConnection = Effort.DbConnectionFactory.CreateTransient();
using var context = new MarketDbContext(inMemoryConnection);
context.Init();
RegisteredUser first_owner = new RegisteredUser("FIRST_OWNER", new byte[] { });
context.Users.Add(first_owner);
TEST_FIRST_OWNER = first_owner.ID;
RegisteredUser owner = new RegisteredUser("OWNER", new byte[] { });
context.Users.Add(owner);
TEST_OWNER = owner.ID;
RegisteredUser manager = new RegisteredUser("MANAGER", new byte[] { });
context.Users.Add(manager);
TEST_MANAGER = manager.ID;
RegisteredUser new_user = new RegisteredUser("NEW_USER", new byte[] { });
context.Users.Add(new_user);
TEST_NEW_USER = new_user.ID;
storeName = DataForTests.CreateTestContactDetails().Name;
storeHandler = new StoreHandler();
orderManager = new OrderManager(storeHandler, inMemoryConnection);
storeManagement = new StoreManagementFacade(storeHandler, orderManager);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), TEST_FIRST_OWNER, context);
Store store = storeHandler.GetStoreByName(storeName, context);
store.AddOwner(TEST_OWNER, TEST_FIRST_OWNER, STUB_USER_NAME, storeHandler, context);
store.AddManager(TEST_MANAGER, TEST_OWNER, context);
item = store.AddItem("existing", 2, categories1, 3.55, context);
itemID = item.Id;
storeID = store.Id;
}
public void Setup()
{
inMemoryConnection = DbConnectionFactory.CreateTransient();
using var context = new MarketDbContext(inMemoryConnection);
context.Init();
RegisteredUser opener = new RegisteredUser("OPENER", new byte[] { });
context.Users.Add(opener);
Guid openerID = opener.ID;
storeID = Guid.NewGuid();
Store store = new Store(storeID, DataForTests.CreateTestContactDetails(), new PurchasePolicy(storeID), new DiscountPolicy(storeID), openerID, context);// only for consistency in Db
context.Stores.Add(store);
////context.Categories.AddRange(categories);
//foreach (Category category in categories)
//{
// context.Categories.Add(category);
//}
id = Guid.NewGuid();
//item = new Item(id, storeID, "item", 5, categories, 50);
item = store.AddItem("item", 5, stringCategories, 50, context);
id = item.Id;
//store.storeInventory.StoreItems.Add(item);
//context.Items.Add(item);
context.SaveChanges();
//StoreInventory storeInventory = store.storeInventory;
//storeInventory.StoreItems.Add(item);
//context.SaveChanges();
}
private void TestAllConditionsAndFilters(string nameToSearch, string nameToFind)
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(
context: context,
filterItemRank: 0,
filterMinPrice: 20.4,
filterMaxPrice: 20.4,
filterStoreRank: 0,
name: nameToSearch,
category: "cat2",
keywords: new List <string>()
{
"word3"
});
Assert.AreEqual(2, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore2 = results[stores[2].Id];
Assert.AreEqual(nameToFind, resultStore[0].Name);
Assert.AreEqual(nameToFind, resultStore2[0].Name);
Assert.AreEqual(1, resultStore.Count);
Assert.AreEqual(1, resultStore2.Count);
}
public void SearchItems_ByName_NameCorrect_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(
context: context,
filterItemRank: null,
filterMinPrice: null,
filterMaxPrice: null,
filterStoreRank: null,
name: "item one");
Assert.AreEqual(3, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
ReadOnlyCollection <Item> resultStore2 = results[stores[2].Id];
Assert.AreEqual("item one", resultStore[0].Name);
Assert.AreEqual("item one", resultStore1[0].Name);
Assert.AreEqual("item one", resultStore2[0].Name);
Assert.AreEqual(1, resultStore.Count);
Assert.AreEqual(1, resultStore1.Count);
Assert.AreEqual(1, resultStore2.Count);
}
public void SearchItems_ByName_spellMistake_SpellingCannotHelp_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
IStoreInventoryManager inventoryManager3 = storeHandler.GetStoreInventoryManager(stores[3].Id, context);
inventoryManager3.AddItem("apple computer", 300, new HashSet <string>()
{
"electrical"
}, 2000, context,
keyWords: new HashSet <string>()
{
"computers", "electronic"
});
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(context: context,
filterItemRank: null,
filterMinPrice: 11,
filterMaxPrice: 2000,
filterStoreRank: null,
name: "paplee compuetr",
category: "electrical");
Assert.AreEqual(0, results.Keys.Count);
}
public void Setup()
{
inMemoryConnection = DbConnectionFactory.CreateTransient();
using var context = new MarketDbContext(inMemoryConnection);
context.Init();
filterStoreRank = new FilterByStoreRank(4);
filterByItemRank = new FilterByItemRank(3);
filterByPrice = new FilterByPrice(5, 20.66);
RegisteredUser owner = new RegisteredUser("OWNER", new byte[] { });
context.Users.Add(owner);
Guid Owner = owner.ID;
Guid storeID = Guid.NewGuid();
store = new Store(storeID, DataForTests.CreateTestContactDetails(), new PurchasePolicy(storeID), new DiscountPolicy(storeID), Owner, context);
context.Stores.Add(store);
HashSet <Category> categories = new HashSet <Category>()
{
new Category("cat1"), new Category("cat2")
};
context.Categories.AddRange(categories);
item = new Item(Guid.NewGuid(), store.Id, "name ", 2, categories, 3.55);
context.Items.Add(item);
context.SaveChanges();
}
public void EditStoreContactDetails_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context);
Store store = storeHandler.GetStoreByName("store", context);
Dictionary <StoresUtils.StoreEditContactDetails, object> newDetails = new Dictionary <StoresUtils.StoreEditContactDetails, object>()
{
{ StoresUtils.StoreEditContactDetails.name, "newStore" },
{ StoresUtils.StoreEditContactDetails.email, "new email" },
{ StoresUtils.StoreEditContactDetails.address, "newAddress" },
{ StoresUtils.StoreEditContactDetails.bankAccountNumber, "888-222222/20" },
{ StoresUtils.StoreEditContactDetails.bank, "Poalim" },
};
Assert.IsTrue(storeHandler.EditStoreContactDetails(store.Id, newDetails, context));
store = storeHandler.GetStoreById(store.Id, context);
StoreContactDetails storeContactDetails = store.ContactDetails;
Assert.AreEqual(storeContactDetails.Name, "newStore");
Assert.AreEqual(storeContactDetails.Email, "new email");
Assert.AreEqual(storeContactDetails.Address, "newAddress");
Assert.AreEqual(storeContactDetails.Phone, "0544444444");
Assert.AreEqual(storeContactDetails.BankAccountNumber, "888-222222/20");
Assert.AreEqual(storeContactDetails.Bank, "Poalim");
Assert.AreEqual(storeContactDetails.Description, "Store description");
}
public void SearchItems_ByCategory_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results = storeHandler.SearchItems(context: context, category: "cat2");
Assert.AreEqual(3, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
ReadOnlyCollection <Item> resultStore2 = results[stores[2].Id];
Assert.AreEqual("item two", resultStore[0].Name);
Assert.AreEqual("item three", resultStore[1].Name);
Assert.AreEqual("item two", resultStore1[0].Name);
Assert.AreEqual("item four", resultStore1[1].Name);
Assert.AreEqual("item five", resultStore1[2].Name);
Assert.AreEqual("item two", resultStore2[0].Name);
Assert.AreEqual("item three", resultStore2[1].Name);
Assert.AreEqual("item four", resultStore2[2].Name);
Assert.AreEqual("item five", resultStore2[3].Name);
Assert.AreEqual(2, resultStore.Count);
Assert.AreEqual(3, resultStore1.Count);
Assert.AreEqual(4, resultStore2.Count);
}
public void SearchItems_ByName_PriceFilter_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
SearchFilter priceFilter = new FilterByPrice(null, 20.4);
List <SearchFilter> filters = new List <SearchFilter>()
{
priceFilter
};
Dictionary <Guid, ReadOnlyCollection <Item> > results = storeHandler.SearchItems(context: context,
name: "item one",
filters: filters);
Assert.AreEqual(2, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
Assert.AreEqual("item one", resultStore[0].Name);
Assert.AreEqual("item one", resultStore1[0].Name);
Assert.AreEqual(1, resultStore.Count);
Assert.AreEqual(1, resultStore1.Count);
}
public void SearchItems_ByNameAndCategoryAndKeyWords_FilterByPrice_SpellMistake_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(context: context,
filterItemRank: null,
filterMinPrice: null,
filterMaxPrice: 20.4,
filterStoreRank: null,
name: "itam one",
category: "cat1",
keywords: new List <string>()
{
"word1"
});
Assert.AreEqual(2, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
Assert.AreEqual("item one", resultStore[0].Name);
Assert.AreEqual("item one", resultStore1[0].Name);
Assert.AreEqual(1, resultStore.Count);
Assert.AreEqual(1, resultStore1.Count);
}
public void SearchItems_ByKeyWords_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(context: context,
filterItemRank: null,
filterMinPrice: null,
filterMaxPrice: null,
filterStoreRank: null,
keywords: new List <string>()
{
"word50"
});
Assert.AreEqual(2, results.Keys.Count);
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
ReadOnlyCollection <Item> resultStore3 = results[stores[3].Id];
Assert.AreEqual("item five", resultStore1[0].Name);
Assert.AreEqual("item twenty", resultStore3[0].Name);
Assert.AreEqual(1, resultStore1.Count);
Assert.AreEqual(1, resultStore3.Count);
}
private ResponseClass DeserializeOpenStore(Guid sessionID, string storeName)
{
StoreContactDetails details = DataForTests.CreateTestContactDetails();
string json = marketFacade.OpenStore(sessionID, storeName, details.Email, details.Address, details.Phone, details.BankAccountNumber,
details.Bank, details.Description, null, null);
return(JsonConvert.DeserializeObject <ResponseClass>(json));
}
public void SearchItems_ByName_NoSuchName_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results = storeHandler.SearchItems(context: context, name: "noSuchName");
Assert.AreEqual(0, results.Keys.Count);
}
public void OpenStore_AndTryAnotherSameOne_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Assert.DoesNotThrow(() => storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context));
Assert.Throws(Is.TypeOf <StoreAlreadyExistException>()
.And.Message.EqualTo(string.Format("Store with name {0} already exists", "store")),
() => storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context));
}
public void GetStoreByName_NoSuchStore_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context); //just for initialization
Assert.Throws(Is.TypeOf <StoreNotFoundException>()
.And.Message.EqualTo(string.Format("Invalid store name: {0}", "NoStoreName")),
() => storeHandler.GetStoreByName("NoStoreName", context));
}
public void GetAllStoresInformation_StoreHasNoItems_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store store = storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context);
ReadOnlyCollection <Store> data = searchFacade.GetAllStoresInformation(context);
Assert.AreEqual(1, data.Count);
Assert.IsTrue(data.Contains(store));
Assert.AreEqual(0, store.GetStoreItems().Count);
}
public void SetStoreRankById_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context);
Store store = storeHandler.GetStoreByName("store", context);
storeHandler.SetStoreRankById(store.Id, 3.33, context);
store = storeHandler.GetStoreByName("store", context);
Assert.AreEqual(3.33, store.Rank);
}
public void GetStoreById_NoSuchStore_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context); //just for initialization
Guid fakeId = Guid.NewGuid();
Assert.Throws(Is.TypeOf <StoreNotFoundException>()
.And.Message.EqualTo(string.Format("Invalid Store id: {0}", fakeId)),
() => storeHandler.GetStoreById(fakeId, context));
}
public void GetStoreCertificationManager_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
StoreContactDetails storeContactDetails = DataForTests.CreateTestContactDetails();
storeHandler.OpenStore(storeContactDetails, Owner, context);
Store store = storeHandler.GetStoreByName("store", context);
IStoreCertificationManager scm = storeHandler.GetStoreCertificationManager(store.Id, context);
Assert.AreEqual(store, scm);
}
public void SearchItems_ByCategory_StoreRankFilterItemRankFilter_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
SearchFilter storeRankFilter = new FilterByStoreRank(4.5);
SearchFilter itemRankFilter = new FilterByItemRank(6.5);
List <SearchFilter> filters = new List <SearchFilter>()
{
storeRankFilter, itemRankFilter
};
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
storeHandler.SetStoreRankById(stores[0].Id, 4.5, context);
storeHandler.SetStoreRankById(stores[1].Id, 3, context);
//update rank of item2 of "store"
ReadOnlyCollection <Item> items_Store = stores[0].GetStoreItems();
Guid itemId2 = items_Store[1].Id;
Dictionary <StoresUtils.ItemEditDetails, object> newDetails_item2 = new Dictionary <StoresUtils.ItemEditDetails, object>()
{
{ StoresUtils.ItemEditDetails.rank, 6.5 }
};
IStoreInventoryManager storeInventoryManager = storeHandler.GetStoreInventoryManager(stores[0].Id, context);
storeInventoryManager.EditItem(itemId2, newDetails_item2, context);
//update rank of item5 of "store1"
ReadOnlyCollection <Item> items_Store1 = stores[1].GetStoreItems();
Guid itemId5 = items_Store1[3].Id;
Dictionary <StoresUtils.ItemEditDetails, object> newDetails_item5 = new Dictionary <StoresUtils.ItemEditDetails, object>()
{
{ StoresUtils.ItemEditDetails.rank, 6.9 }
};
IStoreInventoryManager storeInventoryManager1 = storeHandler.GetStoreInventoryManager(stores[1].Id, context);
storeInventoryManager1.EditItem(itemId5, newDetails_item5, context);
//start search test
Dictionary <Guid, ReadOnlyCollection <Item> > results = storeHandler.SearchItems(context: context, category: "cat2",
filters: filters);
Assert.AreEqual(1, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
Assert.AreEqual("item two", resultStore[0].Name);
Assert.AreEqual(1, resultStore.Count);
}
public void GetAllStoresInformation_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
ReadOnlyCollection <Store> data = searchFacade.GetAllStoresInformation(context);
Assert.AreEqual(4, data.Count);
foreach (Store store in stores)
{
Assert.IsTrue(data.Contains(store));
}
}
public void GetStoreById_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context);
StoreContactDetails storeContactDetails2 = DataForTests.CreateTestContactDetails();
storeContactDetails2.Name = "store2";
storeHandler.OpenStore(storeContactDetails2, Owner, context);
Store store = storeHandler.GetStoreByName("store", context);
Assert.AreEqual(store, storeHandler.GetStoreById(store.Id, context));
}
public void SearchItems_ByName_NoSuchName_SpellCheckerShouldNotFindAnswer_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(context: context,
filterItemRank: null,
filterMinPrice: null,
filterMaxPrice: null,
filterStoreRank: null,
name: "noSuchName");
Assert.AreEqual(0, results.Keys.Count);
}
public void OpenStore_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store s = null;
Assert.DoesNotThrow(() => s = storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), Owner, context));
Assert.AreEqual("store", s.ContactDetails.Name);
Assert.AreEqual("*****@*****.**", s.ContactDetails.Email);
Assert.AreEqual("Address", s.ContactDetails.Address);
Assert.AreEqual("0544444444", s.ContactDetails.Phone);
Assert.AreEqual("888-444444/34", s.ContactDetails.BankAccountNumber);
Assert.AreEqual("Leumi", s.ContactDetails.Bank);
Assert.AreEqual("Store description", s.ContactDetails.Description);
}
public void SearchItems_RequestAllItems_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
Dictionary <Guid, ReadOnlyCollection <Item> > results = storeHandler.SearchItems(context: context);
Assert.AreEqual(4, results.Keys.Count);
ReadOnlyCollection <Item> resultStore = results[stores[0].Id];
ReadOnlyCollection <Item> resultStore1 = results[stores[1].Id];
ReadOnlyCollection <Item> resultStore2 = results[stores[2].Id];
ReadOnlyCollection <Item> resultStore3 = results[stores[3].Id];
Assert.AreEqual(3, resultStore.Count);
Assert.AreEqual(4, resultStore1.Count);
Assert.AreEqual(5, resultStore2.Count);
Assert.AreEqual(1, resultStore3.Count);
}
public void Setup()
{
inMemoryConnection = DbConnectionFactory.CreateTransient();
using var context = new MarketDbContext(inMemoryConnection);
context.Init();
storeID = Guid.NewGuid();
RegisteredUser owner = new RegisteredUser("OWNER", new byte[] { });
context.Users.Add(owner);
context.SaveChanges();
Guid Owner = owner.ID;
Store store = new Store(storeID, DataForTests.CreateTestContactDetails(), new PurchasePolicy(storeID), new DiscountPolicy(storeID), Owner, context);
context.Stores.Add(store);
context.SaveChanges();
storeInventory = store.storeInventory;
categories1 = new HashSet <string>()
{
"cat1"
};
categories2 = new HashSet <string>()
{
"cat1", "cat2"
};
categories3 = new HashSet <string>()
{
"cat1", "cat2", "cat3"
};
keywords1 = new HashSet <string>()
{
"word1"
};
keywords2 = new HashSet <string>()
{
"word1", "word2"
};
keywords3 = new HashSet <string>()
{
"word1", "word2", "word3"
};
}
public void GetStores_ShouldPass()
{
using var context = new MarketDbContext(inMemoryConnection);
StoreContactDetails storeContactDetails = DataForTests.CreateTestContactDetails();
storeHandler.OpenStore(storeContactDetails, Owner, context);
Store store = storeHandler.GetStoreByName(storeContactDetails.Name, context);
Assert.IsTrue(storeHandler.Stores(context).Contains(store));
Assert.AreEqual(1, storeHandler.Stores(context).Count);
StoreContactDetails storeContactDetails2 = DataForTests.CreateTestContactDetails();
storeContactDetails2.Name = "store2";
storeHandler.OpenStore(storeContactDetails2, Owner, context);
Store store2 = storeHandler.GetStoreByName(storeContactDetails.Name, context);
Assert.IsTrue(storeHandler.Stores(context).Contains(store));
Assert.IsTrue(storeHandler.Stores(context).Contains(store2));
Assert.AreEqual(2, storeHandler.Stores(context).Count);
}
public void SearchItems_ByCategory_WithPriceFilter_NoSuchItems_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
Store[] stores = DataForTests.CreateStoresForSearchTests(storeHandler, context);
SearchFilter priceFilter = new FilterByPrice(null, 3);
List <SearchFilter> filters = new List <SearchFilter>()
{
priceFilter
};
Dictionary <Guid, ReadOnlyCollection <Item> > results =
searchFacade.SearchItems(context: context,
filterItemRank: null,
filterMinPrice: null,
filterMaxPrice: 3,
filterStoreRank: null,
category: "cat2");
Assert.AreEqual(0, results.Keys.Count);
}
public void EditStoreContactDetails_EditNameToExistingStoreName_ShouldFail()
{
using var context = new MarketDbContext(inMemoryConnection);
StoreContactDetails storeContactDetails1 = DataForTests.CreateTestContactDetails();
storeHandler.OpenStore(storeContactDetails1, Owner, context);
StoreContactDetails storeContactDetails2 = DataForTests.CreateTestContactDetails();
storeContactDetails2.Name = "store2";
storeHandler.OpenStore(storeContactDetails2, Owner, context);
Store store = storeHandler.GetStoreByName("store", context);
Dictionary <StoresUtils.StoreEditContactDetails, object> newDetails = new Dictionary <StoresUtils.StoreEditContactDetails, object>()
{
{ StoresUtils.StoreEditContactDetails.name, "store2" },
};
Assert.Throws(Is.TypeOf <StoreAlreadyExistException>()
.And.Message.EqualTo(string.Format("Store with name {0} already exists", "store2")),
() => storeHandler.EditStoreContactDetails(store.Id, newDetails, context));
}
