public void Test_newOrder()
{
var store = new NewYorkStore();
var sut = store.newOrder(new Domain.Models.Orders.Customer(), new Domain.Models.Orders.Order());
Assert.True(sut);
}
public void Test_Order_Fact()
{
// Arrange
List <APizza> myPizzas = new List <APizza>();
myPizzas.Add(new CheesePizza());
Customer cust = new Customer("John Smith", "*****@*****.**");
NewYorkStore store = new NewYorkStore();
var myOrder = new Order(myPizzas, store.Name, cust);
var expectedStore = "New York Store";
var expectedCustomer = cust;
var expectedPizza = myPizzas;
//act
var actualStore = myOrder.StoreName;
var actualCustomer = myOrder.Cust;
var actualPizza = myOrder.Pizzas;
//Assert
Assert.Equal(expectedStore, actualStore);
Assert.Equal(expectedCustomer, actualCustomer);
Assert.Equal(expectedPizza, actualPizza);
}
public void Test_NewYorkStore()
{
var sut = new NewYorkStore();
var actual = sut.Name;
Assert.True(actual.Equals("NewYorkStore"));
}
public void TestNewYorkStore()
{
var sut = new NewYorkStore();
var actual = sut.name;
Assert.True(sut.name.Equals("NewYork Store"));
Assert.True(sut.ToString() == actual);
}
public void Test_NYStore_Theory(string expected)
{
var sut = new NewYorkStore();
var actual = sut.storeName;
Assert.Equal(expected, actual);
}
public void Test_NewYorkStore()
{
var sut = new NewYorkStore();
var expected = "NewYork Pizza Store";
var actual = sut.Name;
Assert.Equal(expected, actual);
}
public void Test_NYStore_Fact()
{
var sut = new NewYorkStore(); //we want to test this
var expected = "NewYork Store"; //expect this
var actual = sut.storeName;
Assert.Equal(expected, actual);
}
public static void SeedData()
{
// For some reason EF doesn't like this
// if a command runs that doesn't update a row
// EF will completely error out and stop all transactionsg
//_context.Database.ExecuteSqlRaw("ALTER INDEX IX_Toppings_ToppingType on dbo.Toppings SET ( IGNORE_DUP_KEY = ON )");
//_context.Database.ExecuteSqlRaw("ALTER INDEX IX_Crusts_CrustType on dbo.Crusts SET ( IGNORE_DUP_KEY = ON )");
//_context.Database.ExecuteSqlRaw("ALTER INDEX IX_Stores_Name on dbo.Stores SET ( IGNORE_DUP_KEY = ON )");
//_context.Database.ExecuteSqlRaw("ALTER INDEX IX_Sizes_SizeType on dbo.Sizes SET ( IGNORE_DUP_KEY = ON )");
//_context.Database.ExecuteSqlRaw("ALTER INDEX IX_Customers_Name on dbo.Customers SET ( IGNORE_DUP_KEY = ON )");
OrderRepository orderRepository = new OrderRepository(DbContextSingleton.Instance.Context);
Customer cust = new Customer("Nick");
AStore store = new NewYorkStore();
store.Name = "Test New York Store";
Order order = new Order();
order.Store = store;
order.Customer = cust;
APizza pizza = new CustomPizza();
pizza.Crust = new DeepDishCrust();
pizza.Size = new SmallSize();
pizza.Toppings = new List <Topping>();
pizza.Toppings.Add(new BaconTopping());
pizza.Toppings.Add(new PepperoniTopping());
order.Pizzas = new List <APizza>()
{
pizza,
new VeganPizza(),
new MeatPizza()
};
orderRepository.Add(order);
pizza.Size = new LargeSize();
pizza.Toppings = new List <Topping>();
pizza.Toppings.Add(new BaconTopping());
pizza.Toppings.Add(new OnionTopping());
order.Store.Name = "Test Store 2";
orderRepository.Add(order);
/*
* public Store Store { get; set; }
* public Customer Customer { get; set; }
* public List<Pizza> Pizzas { get; set; }
* public decimal TotalPrice { get; set; }
* public DateTime OrderTime { get; set; }
*
*/
}
public void Test_NewYorkStore()
{
//arrange
var sut = new NewYorkStore();
//act
//assert
Assert.True(sut.name.Equals("NewYorkStore"));
}
public void TestAddNYStore()
{
var sut = new Order();
var store = new NewYorkStore()
{
Name = "3rd St"
};
sut.Store = store;
Assert.True(sut.Store is AStore);
}
public void Test_StoreEnum()
{
// arrange
var sut = new NewYorkStore();
// act
var actual = sut.STORE;
// assert
Assert.True(actual == STORES.NEWYORK);
}
public void Test_NYStore()
{
//arrange (sut = subject under test)
var sut = new NewYorkStore();
//act
var actual = sut.name;
// assert
Assert.True(actual == "NewYorkStore");
}
public void Test_NewYorktore_Name()
{
// arrange
var sut = new NewYorkStore();
// act
var actual = sut.Name;
// assert
Assert.IsType <string>(actual);
}
public void Test_ChicagoStore_NotNull()
{
// arrange
var sut = new NewYorkStore();
// act
var actual = sut;
// assert
Assert.NotNull(actual);
}
public void Test_NewYorkStoreName()
{
// arrange
var sut = new NewYorkStore();
// act
var actual = sut.Name;
// assert
Assert.True(actual == "NewYorkStore");
}
public void Test_NewYorkStore_Fact()
{
//Arrange
var sut = new NewYorkStore();
var expected = "New York Store";
//act
var actual = sut.Name;
//Assert
Assert.Equal(expected, actual);
}
public void Test_hasPizzaPrice()
{
var pizza = new CheesePizza();
pizza.addCrust(new MediumCrust());
var store = new NewYorkStore();
var order = new Domain.Models.Orders.Order();
store.newOrder(new Domain.Models.Orders.Customer(), order);
store.addPizza(order, pizza);
Assert.True(order.price == pizza.price);
}
private StoreSingleton(PizzaBoxContext context)
{
_context = context;
Stores = _context.Stores.ToList();
if (Stores == null)
{
var s = new ChicagoStore();
var n = new NewYorkStore();
_context.Add(s);
_context.Add(n);
}
//Stores = _context.Stores.ToList();
}
public void Test_notHavePizzaPrice()
{
var pizza = new CheesePizza();
pizza.addCrust(new MediumCrust());
var store = new NewYorkStore();
var order = new Domain.Models.Orders.Order();
store.newOrder(new Domain.Models.Orders.Customer(), order);
store.addPizza(order, pizza);
store.removePizza(order, pizza);
Assert.False(order.pizzas.Contains(pizza));
}
/// <summary>
/// Map DBStore => AStore
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public AStore Map(DBStore entity)
{
AStore store = null;
switch (entity.STORE)
{
case Entities.EntityModels.STORES.NEWYORK:
store = new NewYorkStore();
break;
case Entities.EntityModels.STORES.CHICAGO:
store = new ChicagoStore();
break;
default:
throw new ArgumentException("Store not recognized. Store could not be mapped properly");
}
return(store);
}
public AStore Map(Store model)
{
AStore aStore = null;
switch (model.StoreType)
{
case STORE_TYPE.Chicago:
aStore = new ChicagoStore();
break;
case STORE_TYPE.NewYork:
aStore = new NewYorkStore();
break;
case STORE_TYPE.Unknown:
// TODO: add logging to these last 2
default:
throw new ArgumentException("Store mapper is attempting to map a store type that does not exist in the codebase");
}
aStore.Name = model.Name;
return(aStore);
}
public void ToString_test()
{
var Store = new NewYorkStore();
Assert.True(Store.ToString() == Store.name);
}
public void Test_NewYorkStore()
{
var sut = new NewYorkStore();
Assert.True(sut.Name.Equals("NewYorkStore"));
}
