protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
string action = HYRequest.GetQueryString("action");
if (action == "cancelorder") //取消订单
{
int orderid = HYRequest.GetQueryInt("orderid", 0);
OrderFactory.UpdateStatus(99, orderid);
Response.Redirect("user_order.aspx");
}
int s = HYRequest.GetQueryInt("s", 0);
int pageindex = HYRequest.GetQueryInt("p", 1);
int pagesize = 5;
int totalcount = 0;
if (s == 0)
{
OrderList = OrderFactory.GetOrderList(pagesize, pageindex, " where uid=" + this.LoginUser.uid + " and orderstatus>1 ", " order by orderid desc ", out totalcount);
}
else if (s == 1) //已下单未付款
{
OrderList = OrderFactory.GetOrderList(pagesize, pageindex, " where uid=" + this.LoginUser.uid + " and (orderstatus=2 or orderstatus=3) ", " order by orderid desc ", out totalcount);
}
else if (s == 2) //已付款
{
OrderList = OrderFactory.GetOrderList(pagesize, pageindex, " where uid=" + this.LoginUser.uid + " and orderstatus=5 ", " order by orderid desc ", out totalcount);
}
}
}
private void orderSaveButton_Click(object sender, EventArgs e)
{
try
{
ValidateOrderFormInputs();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Warning");
return;
}
Product product = (Product)productsComboBox.SelectedItem;
Person person = (Person)personsComboBox.SelectedItem;
int amount = int.Parse(amountTextBox.Text);
if (product.StockAmount >= amount)
{
Order order = OrderFactory.Create(product, person, amount);
_orderRepository.Save(order);
AddOrderToListView(order);
DecreaseProductStockAmount(order.Product, order.Amount);
RefreshProductsListView(_productRepository.FindAll());
}
else
{
MessageBox.Show("Insufficient stock quantity", "Warning");
}
ClearOrderInputs();
}
public void Attack(BaseUnitInfo attacker, DetectedUnitInfo attackee, GameConstants.EngagementOrderType engagementOrderType, string weaponClassID, int roundCount)
{
if (attacker != null && attackee != null)
{
//~ ShowInfo(string.Format("*** Unit {0} to engage target {1}", unit.UnitName, det.DetectedUnitDescription));
UnitEngagementOrder order = OrderFactory.CreateEngagementOrder(attacker.Id, attackee.Id, weaponClassID, engagementOrderType,
GameConstants.EngagementStrength.DefaultAttack, false);
//order.DetectedUnitId = attackee.Id;
//order.Id = attacker.Id;
//if (weaponClassID != null)
//{
// order.WeaponClassID = weaponClassID;
//}
//if (roundCount != null && roundCount > 0)
//{
// order.RoundCount = roundCount;
//}
//order.EngagementType = engagementOrderType;
GameManager.Instance.NetworkManager.Send(order);
GameManager.Instance.MessageManager.AddMessage(string.Format("Attacking {0} with unit {1}", attackee.Id, attacker.Id), GameManager.MessageTypes.Battle, attackee.Position);
}
else
{
//~ ShowInfo("Select own unit and detected unit to engage.");
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonToken = JToken.Load(reader);
if (jsonToken.Type == JTokenType.Array)
{
var orders = new List <IOrder>();
var jsonArray = (JArray)jsonToken;
foreach (var item in jsonArray)
{
var order = OrderFactory.Create(item["type"].Value <string>());
serializer.Populate(item.CreateReader(), order);
orders.Add(order);
}
return(orders);
}
else if (jsonToken.Type == JTokenType.Object)
{
IOrder order = OrderFactory.Create(jsonToken["type"].Value <string>());
serializer.Populate(jsonToken.CreateReader(), order);
return(order);
}
else
{
throw new ArgumentException(string.Format("Unexpected JTokenType ({0}) in reader.", jsonToken.Type.ToString()));
}
}
private OrderFactory CreateOrderFactory()
{
var factoryLogger = Mock.Of <ILogger <OrderFactory> >();
var factory = new OrderFactory(factoryLogger);
return(factory);
}
public void MappingTest()
{
string connectionString = DbTest.CreateEmptyDatabase();
DbMigrations.Run(connectionString);
Order o;
using (OrderContext ctx = new OrderContext(connectionString))
{
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
o = new OrderFactory(new TestNumberGenerator(), new TestBus()).Create("12", "client123");
o.AddProduct(TestSeeding.ProductId);
orderRepository.Save(o);
}
using (OrderContext ctx = new OrderContext(connectionString))
{
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
Order o2 = orderRepository.Get(o.Id);
Assert.True(o2.SameAs(o));
}
}
public void Remove_Deletes_Article_With_OrderLines()
{
//Arrange
var customer = CustomerFactory.CreateValidEntity();
var productToAdd = ProductFactory.CreateValidEntity();
var article = ArticleFactory.CreateValidEntity(productToAdd);
var order = OrderFactory.CreateValidEntity(customer);
var orderLine = OrderLineFactory.CreateValidEntity(order, article);
article.OrderLines.Add(orderLine);
productToAdd.Articles.Add(article);
//Setup ArticleRepository
var articleRepositoryMock = new Mock <IArticleRepository>();
articleRepositoryMock.Setup(ir => ir.Get(It.IsAny <Guid>(), It.IsAny <ArticleIncludes>())).Returns(article);
articleRepositoryMock.Setup(rir => rir.Remove(It.IsAny <Guid>()));
//Setup UnitOfWork
var unitOfWorkMock = new Mock <IUnitOfWork>();
unitOfWorkMock.Setup(uow => uow.Articles).Returns(articleRepositoryMock.Object);
unitOfWorkMock.Setup(uow => uow.Complete()).Returns(1);
var articleService = new ArticleService(unitOfWorkMock.Object);
//Act
var result = articleService.Remove(productToAdd.Id);
//Assert
Assert.IsTrue(result);
}
public void CanGetOrderById(int id)
{
var order = new OrderFactory();
var newOrder = order.get(id);
Assert.True(newOrder.GetType() == typeof(Order));
}
/// <summary>
/// Initializes a new instance of the <see cref="Portfolio"/> class.
/// </summary>
/// <param name="clock">The clock.</param>
/// <param name="actionscheduler">The actionscheduler.</param>
/// <param name="brokerconnection">The brokerconnection.</param>
/// <param name="brokermodel">The brokermodel.</param>
/// <param name="currency">The currency.</param>
/// <param name="eventrunner">The eventrunner.</param>
/// <param name="exceptionhandler">The exceptionhandler.</param>
/// <param name="orderTicketHandler">The order ticket handler.</param>
/// <param name="brokeraccount">The brokeraccount.</param>
/// <param name="cashmanager">The cashmanager.</param>
/// <param name="runmode">The runmode.</param>
/// <param name="datafeed">The datafeed.</param>
/// <param name="benchmark">The benchmark.</param>
/// <param name="id">The identifier.</param>
public Portfolio(WorldClock clock, ActionsScheduler actionscheduler, BrokerConnection brokerconnection, BrokerModel brokermodel,
Currency currency, EventRunner eventrunner, ExceptionHandler exceptionhandler, OrderTicketHandler orderTicketHandler,
BrokerAccount brokeraccount, CashManager cashmanager, RunMode runmode, DataFeed datafeed, Benchmark benchmark, string id = "")
{
//Set references
ActionsScheduler = actionscheduler;
BrokerAccount = brokeraccount;
BrokerConnection = brokerconnection;
BrokerModel = brokermodel;
Clock = clock;
Currency = currency;
EventRunner = eventrunner;
ExceptionHandler = exceptionhandler;
CashManager = cashmanager;
OrderTicketHandler = orderTicketHandler;
_porfolioBenchmark = benchmark;
//Set initial items
Id = id;
IsBacktesting = runmode == RunMode.Backtester;
OrderFactory = new OrderFactory(this, BrokerModel);
OrderTracker = new OrderTracker(this);
Subscription = new DataSubscriptionManager(datafeed, CashManager);
Results = new Result(0, _porfolioBenchmark);
//Portfolio benchmark is not used
benchmark.OnCalc(x => 0);
}
private void PublishOrdersAfterReplay()
{
string currencyPair = "XBTUSD";
Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 100, 407, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 409, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 413, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(10000);
}
public void Add_100_OrderItem()
{
var dbContextScopeFactory = new DbContextScopeFactory();
var ambientDbContextLocator = new AmbientDbContextLocator();
var orderFactory = new OrderFactory();
using (var dbContextScope = dbContextScopeFactory.Create())
{
var personRepository = new PersonRepository(ambientDbContextLocator);
var orderRepository = new OrderRepository(ambientDbContextLocator);
var person = personRepository.GetByName("ding.p");
var order = orderFactory.CreateOrder(person);
orderRepository.Add(order);
for (int i = 0; i < 100; i++)
{
var orderItem = order.CreateItem("A-" + i);
order.OrderLine.Add(orderItem);
}
dbContextScope.SaveChanges();
}
}
public void FindOrdersMaterializeResultsIfCustomerExist()
{
//Arrange
var customerRepository = new Mock <ICustomerRepository>();
var productRepository = new Mock <IProductRepository>();
var orderRepository = new Mock <IOrderRepository>();
Mock <ILogger <SalesAppService> > _mockLogger = new Mock <ILogger <SalesAppService> >();
orderRepository
.Setup(x => x.GetFiltered(It.IsAny <Expression <Func <Order, bool> > >()))
.Returns((Expression <Func <Order, bool> > filter) => {
var orders = new List <Order>();
var customer = new Customer();
customer.ChangeCurrentIdentity(Guid.NewGuid());
orders.Add(OrderFactory.CreateOrder(customer, "name", "city", "address", "zipcode"));
return(orders);
});
var salesManagement = new SalesAppService(productRepository.Object, orderRepository.Object, customerRepository.Object, _mockLogger.Object);
//act
var result = salesManagement.FindOrders(Guid.NewGuid());
//Assert
Assert.NotNull(result);
Assert.True(result.Count == 1);
}
protected void dgOrderList_ItemCommand(object source, DataGridCommandEventArgs e)
{
if (e.CommandArgument.ToString() == "OrderChuhuo") //已送货
{
int dataKey = Convert.ToInt32(this.dgOrderList.DataKeys[e.Item.ItemIndex]);
OrderModel of = OrderFactory.Get(dataKey);
if (of.deliverstatus == 1)
{
of.deliverstatus = 2;
OrderFactory.Update(of);
}
this.LoadListData();
}
else if (e.CommandArgument.ToString() == "OrderShouhuo")
{
int dataKey = Convert.ToInt32(this.dgOrderList.DataKeys[e.Item.ItemIndex]);
OrderModel of = OrderFactory.Get(dataKey);
if (of.deliverstatus == 1 || of.deliverstatus == 2)
{
of.deliverstatus = 3;
OrderFactory.Update(of);
}
this.LoadListData();
}
}
public void OrderRepositoryRemoveItemDeleteIt()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var orderRepository = new OrderRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("0CD6618A-9C8E-4D79-9C6B-4AA69CF18AE6"));
var order = OrderFactory.CreateOrder(
customer,
"shipping name",
"shipping city",
"shipping address",
"shipping zip code");
order.GenerateNewIdentity();
orderRepository.Add(order);
orderRepository.UnitOfWork.Commit();
//Act
orderRepository.Remove(order);
unitOfWork.Commit();
}
public void OrderFactoryCreateValidOrder()
{
//Arrange
string shippingName = "shippingName";
string shippingCity = "shippingCity";
string shippingZipCode = "shippingZipCode";
string shippingAddress = "shippingAddress";
Customer customer = new Customer();
customer.GenerateNewIdentity();
//Act
Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode);
var validationContext = new ValidationContext(order, null, null);
var validationResult = order.Validate(validationContext);
//Assert
ShippingInfo shippingInfo = new ShippingInfo(shippingName, shippingAddress, shippingCity, shippingZipCode);
Assert.AreEqual(shippingInfo, order.ShippingInformation);
Assert.AreEqual(order.Customer, customer);
Assert.AreEqual(order.CustomerId, customer.Id);
Assert.IsFalse(order.IsDelivered);
Assert.IsNull(order.DeliveryDate);
Assert.IsTrue(order.OrderDate != default(DateTime));
Assert.IsFalse(validationResult.Any());
}
public void IsCreditValidForOrderReturnFalseIfTotalOrderIsGreaterThanCustomerCredit()
{
//Arrange
string shippingName = "shippingName";
string shippingCity = "shippingCity";
string shippingZipCode = "shippingZipCode";
string shippingAddress = "shippingAddress";
var country = new Country("spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer("jhon", "el rojo", "+3422", "company", country, new Address("city", "zipCode", "address line1", "addres line2"));
//Act
Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode);
order.AddNewOrderLine(Guid.NewGuid(), 100, 240, 0); // this is greater that 1000 ( default customer credit )
//assert
var result = order.IsCreditValidForOrder();
//Assert
Assert.IsFalse(result);
}
public void OrderGetTotalOrderSumLines()
{
//Arrange
string shippingName = "shippingName";
string shippingCity = "shippingCity";
string shippingZipCode = "shippingZipCode";
string shippingAddress = "shippingAddress";
Customer customer = new Customer();
customer.GenerateNewIdentity();
Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode);
order.AddNewOrderLine(Guid.NewGuid(), 1, 500, 10);
order.AddNewOrderLine(Guid.NewGuid(), 2, 300, 10);
decimal expected = ((1 * 500) * (1 - (10M / 100M))) + ((2 * 300) * (1 - (10M / 100M)));
//Act
decimal actual = order.GetOrderTotal();
//Assert
Assert.AreEqual(expected, actual);
}
public void ConcurrencyTest()
{
string connectionString = DbTest.CreateEmptyDatabase();
DbMigrations.Run(connectionString);
Order o;
OrderContext ctx = new OrderContext(connectionString);
OrderContext ctx2 = new OrderContext(connectionString);
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
IOrderRepository orderRepository2 = new OrderRepository(ctx2, new FakeBus());
o = new OrderFactory(new TestNumberGenerator(), new TestBus()).Create("12", "client123");
o.AddProduct(TestSeeding.ProductId);
orderRepository.Save(o);
Order concurrencyOrder1 = orderRepository.Get(o.Id);
Order concurrencyOrder2 = orderRepository2.Get(o.Id);
concurrencyOrder1.AddProduct(TestSeeding.Product2Id);
concurrencyOrder2.AddProduct(TestSeeding.Product3Id);
orderRepository.Save(concurrencyOrder1);
Assert.Throws <DbUpdateConcurrencyException>(() => orderRepository2.Save(concurrencyOrder2));
}
public async Task <ServiceResponse <CustomerOrderListVM> > GetOrdersByCustomerAsync(string customerId)
{
var response = new ServiceResponse <CustomerOrderListVM>();
try
{
if (string.IsNullOrWhiteSpace(customerId))
{
response.AddNotification("customerId is required");
return(response);
}
var customer = await _customerClient.GetCustomerByIdAsync(customerId);
var orders = await _orderClient.GetOrdersByCustomerAsync(customerId);
if (customer is null)
{
response.AddNotification($"customer {customerId} not found");
return(response);
}
response.Data = new CustomerOrderListVM
{
Orders = orders?.Select(p => OrderFactory.Create(p, customer))?.ToList()
};
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
response.AddNotification("unexpected error");
}
return(response);
}
public void CreateOrders_InvalidNumOrders_ThrowsArgumentException(int numOfOrders)
{
var logger = Mock.Of <ILogger <OrderFactory> >();
var factory = new OrderFactory(logger);
var exception = Assert.Throws <ArgumentOutOfRangeException>(() => factory.CreateOrders(numOfOrders));
}
private void Setup()
{
var partFactory = PartFactoryTestObjects.GetAlwaysValidPartFactory();
CommandFactory = CommandsTestObjects.GetProperAlwaysValidCommandFactory();
var idGenerator = new IdGenerator(4);
var dataPackFactory = new ReflectionBasedDataPackFactory();
var orderFactory = new OrderFactory(idGenerator, dataPackFactory);
var replyFactory = new ReplyFactory(idGenerator);
var confirmationFactory = new ConfirmationFactory();
Mock <IDataStreamSplitter> splitter = new Mock <IDataStreamSplitter>();
Mock <ICommunicationDeviceAsync> comDevice = new Mock <ICommunicationDeviceAsync>();
var translator = new CommandTranslator(new OrderCommandTranslator(partFactory, CommandFactory, orderFactory),
new ReplyCommandTranslator(partFactory, CommandFactory, replyFactory),
new ConfirmationCommandTranslator(partFactory, CommandFactory, confirmationFactory), new ErrorCommandTranslator());
Translator = translator;
Mock <IDeviceHandler> handler = new Mock <IDeviceHandler>();
handler.Setup(h => h.SendAsync(It.IsAny <ICommand>())).ReturnsAsync(true);
DeviceMoq = handler;
ResponseAwaiterDispatch = ResponseAwaiterDispatchTestObjects.GetProperResponseAwaiterDispatch();
ProtocolHandler = new ProtocolHandlerTestWrapper(handler.Object, confirmationFactory, replyFactory, orderFactory, translator, ResponseAwaiterDispatch);
}
public static void RemoveOrder(OrderModel model)
{
UnitOfWorkRepository unitOfWork = new UnitOfWorkRepository();
var order = OrderFactory.ConvertOrderModel(model);
unitOfWork.OrderRepository.RemoveOrder(order.Id);
}
public void Move(double lat, double lng, BaseUnitInfo info, bool removeWaypoints)
{
string Id;
if (info != null)
{
Id = info.Id;
}
else
{
return;
}
UnitMovementOrder order = OrderFactory.CreateUnitMovementOrder(Id, new PositionInfo(lat, lng), removeWaypoints);
//order.Id = Id;
//PositionInfo pos = new PositionInfo();
//pos.Latitude = lat;
//pos.Longitude = lng;
//order.RemoveAllExistingWaypoints = removeWaypoints;
//order.Waypoints.Add(new WaypointInfo(pos));
GameManager.Instance.NetworkManager.Send(order);
//GameManager.Instance.MessageManager.AddMessage(string.Format("Move order sendt. Heading for {0}, {1}", lat, lng), GameManager.MessageTypes.Game);
}
public static void Main(string[] args)
{
// Lazy loading
var orderLazy = new OrderLazy();
var customer = orderLazy.Customer;
orderLazy.PrintLabel();
// Virtual Proxy
var factory = new OrderFactory();
var order = factory.CreateOrder(123);
order.PrintLabel();
order.PrintLabel();
order.PrintLabel();
// Value holder
var valueOrderFactory = new OrderFactoryValueHolder();
var factoryOrder = valueOrderFactory.CreareOrder(11);
var items = factoryOrder.Items;
var items2 = factoryOrder.Items;
var items3 = factoryOrder.Items;
Console.ReadKey();
}
public void ReturnToBase(PlayerUnit unit)
{
GameManager.Instance.NetworkManager.Send(OrderFactory.CreateReturnToBaseOrder(unit.Info.Id));
GameManager.Instance.MessageManager.AddMessage(string.Format(
"Roger! Returning to base. "), GameManager.MessageTypes.Detection, unit.Position);
}
public void FindOrdersMaterializeResultsIfCustomerExist()
{
//Arrange
var customerRepository = new SICustomerRepository();
var productRepository = new SIProductRepository();
var orderRepository = new SIOrderRepository();
orderRepository.GetFilteredExpressionOfFuncOfOrderBoolean = (filter) =>
{
var orders = new List <Order>();
var customer = new Customer();
customer.ChangeCurrentIdentity(Guid.NewGuid());
orders.Add(OrderFactory.CreateOrder(customer, "name", "city", "address", "zipcode"));
return(orders);
};
var salesManagement = new SalesAppService(productRepository, orderRepository, customerRepository);
//act
var result = salesManagement.FindOrders(Guid.NewGuid());
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Count == 1);
}
public void GetOpenOrders_IfTraderIdIsProvided_RetrievedOrdersShouldBeDateTimeSortedAsDescending()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
Order order = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
Order order1 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
Order order2 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
resetEvent.WaitOne(2000);
resetEvent.Reset();
OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order);
_persistanceRepository.SaveOrUpdate(model);
OrderReadModel model1 = ReadModelAdapter.GetOrderReadModel(order1);
_persistanceRepository.SaveOrUpdate(model1);
OrderReadModel model2 = ReadModelAdapter.GetOrderReadModel(order2);
_persistanceRepository.SaveOrUpdate(model2);
IList <OrderReadModel> getReadModel = _orderRepository.GetOpenOrders("100");
Assert.NotNull(getReadModel);
Assert.AreEqual(getReadModel.Count, 3);
Assert.True(getReadModel[0].DateTime > getReadModel[1].DateTime);
Assert.True(getReadModel[1].DateTime > getReadModel[2].DateTime);
}
public void CanParseDate(string date)
{
var order = new OrderFactory();
DateTime?parsedDate = order.ParseDate(date);
Assert.Equal <DateTime?>(new DateTime(2016, 05, 10), parsedDate);
}
// Sample usage of factory and repository
public void CreateNewOrder()
{
Client client = LoadClient(SystemUser.UserId);
Order order = OrderFactory.CrateOrder(client);
OrderRepository.Save(order);
}
public void Order_Fetch_returns_old_Order_with_expected_data()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock DTO's
var lineItemDto1 = mocks.StrictMock <ILineItemDto>();
Expect.Call(lineItemDto1.Id).Return(200).Repeat.Any();
Expect.Call(lineItemDto1.ProductName).Return("Widget A").Repeat.Any();
Expect.Call(lineItemDto1.Price).Return(10M).Repeat.Any();
Expect.Call(lineItemDto1.Quantity).Return(2).Repeat.Any();
Expect.Call(lineItemDto1.Timestamp).Return(new byte[8]).Repeat.Any();
var lineItemDto2 = mocks.StrictMock <ILineItemDto>();
Expect.Call(lineItemDto2.Id).Return(201).Repeat.Any();
Expect.Call(lineItemDto2.ProductName).Return("Widget B").Repeat.Any();
Expect.Call(lineItemDto2.Price).Return(20.5M).Repeat.Any();
Expect.Call(lineItemDto2.Quantity).Return(3).Repeat.Any();
Expect.Call(lineItemDto2.Timestamp).Return(new byte[8]).Repeat.Any();
var orderDto1 = mocks.StrictMock <IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(new byte[8]).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new[] { lineItemDto1, lineItemDto2 }).Repeat.Any();
//mock read context
IOrderContext readContext = mocks.StrictMock <IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock repository
var repository = base.MockRepository <IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
//test state of entity
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.Id, Is.EqualTo(100));
Assert.That(entity.Customer, Is.EqualTo("Bob"));
Assert.That(entity.Date, Is.EqualTo(DateTime.Parse("1/1/2008")));
Assert.That(entity.ShippingCost, Is.EqualTo(5.5M));
//test state of items in child collection
var collection = entity.LineItems;
Assert.That(collection, Is.Not.Null);
Assert.That(collection.Count, Is.EqualTo(2));
ILineItem item;
item = collection[0];
Assert.That(item.ProductName, Is.EqualTo("Widget A"));
Assert.That(item.Price, Is.EqualTo(10M));
Assert.That(item.Quantity, Is.EqualTo(2));
item = collection[1];
Assert.That(item.ProductName, Is.EqualTo("Widget B"));
Assert.That(item.Price, Is.EqualTo(20.5M));
Assert.That(item.Quantity, Is.EqualTo(3));
}
}
public void Order_Create_returns_new_Order()
{
var mocks = new MockRepository();
using (mocks.Record())
{
base.MockRepository<IOrderContext>(mocks);
}
using (mocks.Playback())
{
//create new order
IOrderFactory factory = new OrderFactory();
var entity = factory.Create();
Assert.That(entity.IsNew, Is.True);
}
}
public MorningOrder(OrderFactory orderFactory, int entreeLimit, int sideLimit, int drinkLimit, int desertLimit)
{
this.orderFactory = orderFactory;
Entrees = new List<Dish>();
Sides = new List<Dish>();
Drinks = new List<Dish>();
Deserts = new List<Dish>();
EntreeLimit = entreeLimit;
SideLimit = sideLimit;
DrinkLimit = drinkLimit;
DesertLimit = desertLimit;
InvalidDish = false;
}
public void OrderInfoCollection_Fetch_returns_expected_data()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock data
var orderData1 = mocks.StrictMock<IOrderInfoDto>();
Expect.Call(orderData1.Id).Return(100).Repeat.Any();
Expect.Call(orderData1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderData1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
var orderData2 = mocks.StrictMock<IOrderInfoDto>();
Expect.Call(orderData2.Id).Return(101).Repeat.Any();
Expect.Call(orderData2.Customer).Return("Jim").Repeat.Any();
Expect.Call(orderData2.Date).Return(DateTime.Parse("2/1/2008")).Repeat.Any();
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchInfoList()).Return(new[] { orderData1, orderData2 });
readContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
}
using (mocks.Playback())
{
//fetch collection
IOrderFactory factory = new OrderFactory();
var collection = factory.FetchInfoList();
//test count
Assert.That(collection.Count, Is.EqualTo(2));
//test state of items in collection
IOrderInfo item;
item = collection[0];
Assert.That(item.Id, Is.EqualTo(100));
Assert.That(item.Customer, Is.EqualTo("Bob"));
Assert.That(item.Date, Is.EqualTo(DateTime.Parse("1/1/2008")));
item = collection[1];
Assert.That(item.Id, Is.EqualTo(101));
Assert.That(item.Customer, Is.EqualTo("Jim"));
Assert.That(item.Date, Is.EqualTo(DateTime.Parse("2/1/2008")));
}
}
public void Order_Delete_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock transactional context
IOrderContext trxContext = mocks.StrictMock<IOrderContext>();
trxContext.DeleteOrder(100);
trxContext.CompleteTransaction();
trxContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(true)).Return(trxContext);
}
using (mocks.Playback())
{
//delete order
IOrderFactory factory = new OrderFactory();
factory.Delete(100);
}
}
public void Order_Save_Delete_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock DTO's
var orderDto1 = mocks.StrictMock<IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(new byte[8]).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new ILineItemDto[] { }).Repeat.Any();
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock transactional context
IOrderContext trxContext = mocks.StrictMock<IOrderContext>();
trxContext.DeleteOrder(100);
trxContext.CompleteTransaction();
trxContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
Expect.Call(repository.CreateContext(true)).Return(trxContext);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
//test entity is old
Assert.That(entity.IsNew, Is.False);
//test the delete
entity.Delete();
entity = entity.Save();
Assert.That(entity.IsNew, Is.True);
}
}
public void Order_Save_Update_with_changed_line_items_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
var oldTimestamp = new byte[8];
var newTimestamp = new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 };
//mock DTO's
var lineItemDto1 = mocks.StrictMock<ILineItemDto>();
Expect.Call(lineItemDto1.Id).Return(200).Repeat.Any();
Expect.Call(lineItemDto1.ProductName).Return("Widget A").Repeat.Any();
Expect.Call(lineItemDto1.Price).Return(10M).Repeat.Any();
Expect.Call(lineItemDto1.Quantity).Return(2).Repeat.Any();
Expect.Call(lineItemDto1.Timestamp).Return(oldTimestamp).Repeat.Any();
var lineItemDto2 = mocks.StrictMock<ILineItemDto>();
Expect.Call(lineItemDto2.Id).Return(201).Repeat.Any();
Expect.Call(lineItemDto2.ProductName).Return("Widget B").Repeat.Any();
Expect.Call(lineItemDto2.Price).Return(20.5M).Repeat.Any();
Expect.Call(lineItemDto2.Quantity).Return(3).Repeat.Any();
Expect.Call(lineItemDto2.Timestamp).Return(oldTimestamp).Repeat.Any();
var orderDto1 = mocks.StrictMock<IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(oldTimestamp).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new[] { lineItemDto1, lineItemDto2 }).Repeat.Any();
var updatedLineItemDto2 = mocks.StrictMock<ILineItemDto>();
updatedLineItemDto2.Id = 200;
updatedLineItemDto2.OrderId = 100;
updatedLineItemDto2.ProductName = "Widget A+";
updatedLineItemDto2.Price = 10M;
updatedLineItemDto2.Quantity = 2;
updatedLineItemDto2.Timestamp = oldTimestamp;
Expect.Call(updatedLineItemDto2.Timestamp).Return(newTimestamp);
var instertedLineItemDto3 = mocks.StrictMock<ILineItemDto>();
instertedLineItemDto3.OrderId = 100;
instertedLineItemDto3.ProductName = "Widget C";
instertedLineItemDto3.Price = 15.1M;
instertedLineItemDto3.Quantity = 4;
Expect.Call(instertedLineItemDto3.Id).Return(202);
Expect.Call(instertedLineItemDto3.Timestamp).Return(newTimestamp);
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock transactional context
IOrderContext trxContext = mocks.StrictMock<IOrderContext>();
trxContext.UpdateLineItem(updatedLineItemDto2);
trxContext.DeleteLineItem(201, 100);
trxContext.InsertLineItem(instertedLineItemDto3);
trxContext.CompleteTransaction();
trxContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
Expect.Call(repository.CreateContext(true)).Return(trxContext);
Expect.Call(repository.CreateLineItemDto()).Return(updatedLineItemDto2);
Expect.Call(repository.CreateLineItemDto()).Return(instertedLineItemDto3);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
ILineItem child;
//change line item 1
child = entity.LineItems[0];
child.ProductName = "Widget A+";
//delete line item 2
entity.LineItems.RemoveAt(1);
//add new line item 3
child = entity.LineItems.AddNew();
child.ProductName = "Widget C";
child.Price = 15.1M;
child.Quantity = 4;
//test that entity is old and dirty
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.True);
//perform update
entity = entity.Save();
//test that entity is old and clean
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.False);
}
}
public void Order_Save_Update_with_changed_order_and_no_line_items_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
var oldTimestamp = new byte[8];
var newTimestamp = new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 };
//mock DTO's
var orderDto1 = mocks.StrictMock<IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(oldTimestamp).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new ILineItemDto[] { }).Repeat.Any();
var updatedOrderDto1 = mocks.StrictMock<IOrderDto>();
updatedOrderDto1.Id = 100;
updatedOrderDto1.Customer = "Jim";
updatedOrderDto1.Date = DateTime.Parse("1/1/2008");
updatedOrderDto1.ShippingCost = 5.5M;
updatedOrderDto1.Timestamp = oldTimestamp;
Expect.Call(updatedOrderDto1.Timestamp).Return(newTimestamp);
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock transactional context
IOrderContext trxContext = mocks.StrictMock<IOrderContext>();
trxContext.UpdateOrder(updatedOrderDto1);
trxContext.CompleteTransaction();
trxContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
Expect.Call(repository.CreateContext(true)).Return(trxContext);
Expect.Call(repository.CreateOrderDto()).Return(updatedOrderDto1);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
//change order
entity.Customer = "Jim";
//test that entity is old and dirty
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.True);
//perform update
entity = entity.Save();
//test that entity is old and clean
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.False);
}
}
public void Order_Save_Update_with_unchanged_order_and_no_line_items_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock DTO's
var orderDto1 = mocks.StrictMock<IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(new byte[8]).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new ILineItemDto[] { }).Repeat.Any();
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
//change order, but to same value
entity.Customer = "Bob";
//test that entity is old and clean (since there were no changes)
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.False);
//perform update
entity = entity.Save();
//test that entity is old and clean
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.False);
}
}
public void Order_Fetch_returns_old_Order_with_expected_data()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock DTO's
var lineItemDto1 = mocks.StrictMock<ILineItemDto>();
Expect.Call(lineItemDto1.Id).Return(200).Repeat.Any();
Expect.Call(lineItemDto1.ProductName).Return("Widget A").Repeat.Any();
Expect.Call(lineItemDto1.Price).Return(10M).Repeat.Any();
Expect.Call(lineItemDto1.Quantity).Return(2).Repeat.Any();
Expect.Call(lineItemDto1.Timestamp).Return(new byte[8]).Repeat.Any();
var lineItemDto2 = mocks.StrictMock<ILineItemDto>();
Expect.Call(lineItemDto2.Id).Return(201).Repeat.Any();
Expect.Call(lineItemDto2.ProductName).Return("Widget B").Repeat.Any();
Expect.Call(lineItemDto2.Price).Return(20.5M).Repeat.Any();
Expect.Call(lineItemDto2.Quantity).Return(3).Repeat.Any();
Expect.Call(lineItemDto2.Timestamp).Return(new byte[8]).Repeat.Any();
var orderDto1 = mocks.StrictMock<IOrderDto>();
Expect.Call(orderDto1.Id).Return(100).Repeat.Any();
Expect.Call(orderDto1.Customer).Return("Bob").Repeat.Any();
Expect.Call(orderDto1.Date).Return(DateTime.Parse("1/1/2008")).Repeat.Any();
Expect.Call(orderDto1.ShippingCost).Return(5.5M).Repeat.Any();
Expect.Call(orderDto1.Timestamp).Return(new byte[8]).Repeat.Any();
Expect.Call(orderDto1.LineItems).Return(new[] { lineItemDto1, lineItemDto2 }).Repeat.Any();
//mock read context
IOrderContext readContext = mocks.StrictMock<IOrderContext>();
Expect.Call(readContext.FetchSingleWithLineItems(100)).Return(orderDto1);
readContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(false)).Return(readContext);
}
using (mocks.Playback())
{
//fetch existing order
IOrderFactory factory = new OrderFactory();
var entity = factory.Fetch(100);
//test state of entity
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.Id, Is.EqualTo(100));
Assert.That(entity.Customer, Is.EqualTo("Bob"));
Assert.That(entity.Date, Is.EqualTo(DateTime.Parse("1/1/2008")));
Assert.That(entity.ShippingCost, Is.EqualTo(5.5M));
//test state of items in child collection
var collection = entity.LineItems;
Assert.That(collection, Is.Not.Null);
Assert.That(collection.Count, Is.EqualTo(2));
ILineItem item;
item = collection[0];
Assert.That(item.ProductName, Is.EqualTo("Widget A"));
Assert.That(item.Price, Is.EqualTo(10M));
Assert.That(item.Quantity, Is.EqualTo(2));
item = collection[1];
Assert.That(item.ProductName, Is.EqualTo("Widget B"));
Assert.That(item.Price, Is.EqualTo(20.5M));
Assert.That(item.Quantity, Is.EqualTo(3));
}
}
public void Order_Save_Insert_calls_expected_repository_methods()
{
var mocks = new MockRepository();
using (mocks.Record())
{
//mock DTO's
var insertedOrderDto1 = mocks.StrictMock<IOrderDto>();
insertedOrderDto1.Customer = "Bob";
insertedOrderDto1.Date = DateTime.Parse("1/1/2008");
insertedOrderDto1.ShippingCost = 5.5M;
Expect.Call(insertedOrderDto1.Id).Return(100);
Expect.Call(insertedOrderDto1.Timestamp).Return(new byte[8]);
var insertedLineItemDto1 = mocks.StrictMock<ILineItemDto>();
insertedLineItemDto1.OrderId = 100;
insertedLineItemDto1.ProductName = "Widget A";
insertedLineItemDto1.Price = 10M;
insertedLineItemDto1.Quantity = 2;
Expect.Call(insertedLineItemDto1.Id).Return(200);
Expect.Call(insertedLineItemDto1.Timestamp).Return(new byte[8]);
var insertedLineItemDto2 = mocks.StrictMock<ILineItemDto>();
insertedLineItemDto2.OrderId = 100;
insertedLineItemDto2.ProductName = "Widget B";
insertedLineItemDto2.Price = 20.5M;
insertedLineItemDto2.Quantity = 3;
Expect.Call(insertedLineItemDto2.Id).Return(201);
Expect.Call(insertedLineItemDto2.Timestamp).Return(new byte[8]);
//mock transactional context
IOrderContext trxContext = mocks.StrictMock<IOrderContext>();
trxContext.InsertOrder(insertedOrderDto1);
trxContext.InsertLineItem(insertedLineItemDto1);
trxContext.InsertLineItem(insertedLineItemDto2);
trxContext.CompleteTransaction();
trxContext.Dispose();
//mock repository
var repository = base.MockRepository<IOrderContext>(mocks);
Expect.Call(repository.CreateContext(true)).Return(trxContext);
Expect.Call(repository.CreateOrderDto()).Return(insertedOrderDto1);
Expect.Call(repository.CreateLineItemDto()).Return(insertedLineItemDto1);
Expect.Call(repository.CreateLineItemDto()).Return(insertedLineItemDto2);
}
using (mocks.Playback())
{
//create new order
IOrderFactory factory = new OrderFactory();
var entity = factory.Create();
//populate order
entity.Customer = "Bob";
entity.Date = DateTime.Parse("1/1/2008");
entity.ShippingCost = 5.5M;
//add line items
ILineItem child;
child = entity.LineItems.AddNew();
child.ProductName = "Widget A";
child.Price = 10M;
child.Quantity = 2;
child = entity.LineItems.AddNew();
child.ProductName = "Widget B";
child.Price = 20.5M;
child.Quantity = 3;
//test that entity is new and dirty
Assert.That(entity.IsNew, Is.True);
Assert.That(entity.IsDirty, Is.True);
//perform inserts
entity = entity.Save();
//test that entity is old and clean
Assert.That(entity.IsNew, Is.False);
Assert.That(entity.IsDirty, Is.False);
}
}
