Example #1
0
        public void WhenPlacingAnEmptyOrder_WeGetBadRequest()
        {
            // Arrange
            var request = new OrderRequestBuilder()
                          .Order(withOrderId: _orderId)
                          .PlaceOrder()
                          .Build();

            // Act/Assert
            Client.Execute(request, andExpect: System.Net.HttpStatusCode.BadRequest);
        }
Example #2
0
        public void WhenAnOrderDoesntExist_WeGetNotFound()
        {
            // Arrange
            var nonExistentOrder = new ulong().ToString();
            var request          = new OrderRequestBuilder()
                                   .GetOrder(withOrderId: nonExistentOrder)
                                   .Build();

            // Act
            Client.Execute(request, andExpect: System.Net.HttpStatusCode.NotFound);
        }
        public IQueryable <OrderedItem> BuildAfterQuery(
            IQueryable <TDbObject> query,
            Expression <Func <TDbObject, TOrder> > orderBy,
            Expression <Func <TOrder, TOrder, bool> > filter,
            Expression <Func <TDbObject, TResult> > select,
            Cursor after)
        {
            MemberInitExpression orderedItemInit = Expression.MemberInit(
                Expression.New(typeof(OrderedItem)),
                Expression.Bind(OrderMember, ParameterReplacer.RepalceParameter(new SortDirectionRemoverVisitor(orderBy.Body).Expression)),
                Expression.Bind(ValueMember, ParameterReplacer.RepalceParameter(select.Body)));

            Expression queryExpression = query.Expression;

            OrderingFields orderingFields = OrderRequestBuilder.GetOrdering(orderBy);

            if (_cursorFormatter.HasValue(after))
            {
                TOrder order = _cursorFormatter.ParseAs <TOrder>(after);

                Expression filterBody =
                    filter != null
                    ? FilterBuilder.RemapFilter(orderedItemInit, filter, order)
                    : FilterBuilder.BuildAutoFilter(orderedItemInit, orderingFields, order);

                // add where filtration
                queryExpression = Expression.Call(
                    typeof(Queryable),
                    nameof(Queryable.Where),
                    new System.Type[] { typeof(TDbObject) },
                    queryExpression,
                    Expression.Lambda <Func <TDbObject, bool> >(filterBody, DbItem));
            }

            // add passed order
            queryExpression = OrderRequestBuilder.BuildOrderExpression(queryExpression, orderingFields);

            // extend selection and add order fields
            queryExpression = Expression.Call(
                typeof(Queryable),
                nameof(Queryable.Select),
                new System.Type[] { typeof(TDbObject), typeof(OrderedItem) },
                queryExpression,
                Expression.Lambda <Func <TDbObject, OrderedItem> >(orderedItemInit, DbItem));

            return(query.Provider.CreateQuery <OrderedItem>(queryExpression));
        }
Example #4
0
        public void WhenRunningTests_CreateAnOrderIfItDoesntExist()
        {
            // Create a new order.
            SetupTest();

            if (null != _orderId)
            {
                return;
            }

            var request = new OrderRequestBuilder()
                          .CreateOrder()
                          .Build();

            var response = Client.Execute(request, andExpect: System.Net.HttpStatusCode.Created);

            response.Content.Should().NotBeEmpty();
            _orderId = response.Content;
        }