Beispiel #1
0
        public void Init()
        {
            _client = new Client(Helper.GetConfiguration());

            Task <Response <Project.Project> > projectTask = _client.Project().GetProjectAsync();

            projectTask.Wait();
            Assert.IsTrue(projectTask.Result.Success);
            _project = projectTask.Result.Result;

            _testCustomers = new List <Customer>();
            _testPayments  = new List <Payment>();

            for (int i = 0; i < 5; i++)
            {
                CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
                Task <Response <CustomerCreatedMessage> > customerCreatedTask = _client.Customers().CreateCustomerAsync(customerDraft);
                customerCreatedTask.Wait();
                Assert.IsTrue(customerCreatedTask.Result.Success);

                CustomerCreatedMessage customerCreatedMessage = customerCreatedTask.Result.Result;
                Assert.NotNull(customerCreatedMessage.Customer);
                Assert.NotNull(customerCreatedMessage.Customer.Id);

                _testCustomers.Add(customerCreatedMessage.Customer);

                PaymentDraft paymentDraft = Helper.GetTestPaymentDraft(_project, customerCreatedMessage.Customer.Id);
                Task <Response <Payment> > paymentTask = _client.Payments().CreatePaymentAsync(paymentDraft);
                paymentTask.Wait();
                Assert.IsTrue(paymentTask.Result.Success);

                Payment payment = paymentTask.Result.Result;
                Assert.NotNull(payment.Id);

                _testPayments.Add(payment);
            }
        }
Beispiel #2
0
        public async Task ShouldUpdateCartAsync()
        {
            CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
            Response <CustomerCreatedMessage> messageResponse =
                await _client.Customers().CreateCustomerAsync(customerDraft);

            Assert.IsTrue(messageResponse.Success);

            CustomerCreatedMessage customerCreatedMessage = messageResponse.Result;

            Assert.NotNull(customerCreatedMessage.Customer);

            Customer customer = customerCreatedMessage.Customer;

            Assert.NotNull(customer.Id);

            SetCustomerIdAction setCustomerIdAction = new SetCustomerIdAction();

            setCustomerIdAction.CustomerId = customer.Id;

            GenericAction recalculateAction = new GenericAction("recalculate");

            List <UpdateAction> actions = new List <UpdateAction>();

            actions.Add(setCustomerIdAction);
            actions.Add(recalculateAction);

            Response <Cart> cartResponse = await _client.Carts().UpdateCartAsync(_testCarts[0], actions);

            Assert.IsTrue(cartResponse.Success);

            _testCarts[0] = cartResponse.Result;
            Assert.NotNull(_testCarts[0].Id);
            Assert.AreEqual(_testCarts[0].CustomerId, customer.Id);

            await _client.Customers().DeleteCustomerAsync(customer.Id, customer.Version);
        }
Beispiel #3
0
        public async Task ShouldCreateAndDeleteCustomerAsync()
        {
            CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
            Response <CustomerCreatedMessage> customerCreatedResponse = await _client.Customers().CreateCustomerAsync(customerDraft);

            Assert.IsTrue(customerCreatedResponse.Success);

            CustomerCreatedMessage customerCreatedMessage = customerCreatedResponse.Result;

            Assert.NotNull(customerCreatedMessage.Customer);
            Assert.NotNull(customerCreatedMessage.Customer.Id);

            Customer customer = customerCreatedMessage.Customer;

            string deletedCustomerId = customer.Id;

            Response <Customer> customerResponse = await _client.Customers().DeleteCustomerAsync(customer);

            Assert.IsTrue(customerResponse.Success);

            customerResponse = await _client.Customers().GetCustomerByIdAsync(deletedCustomerId);

            Assert.IsFalse(customerResponse.Success);
        }
        public async Task ShouldSetCustomerIdAsync()
        {
            CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
            Response <CustomerCreatedMessage> customerResponse =
                await _client.Customers().CreateCustomerAsync(customerDraft);

            Assert.IsTrue(customerResponse.Success);

            CustomerCreatedMessage customerCreatedMessage = customerResponse.Result;

            Assert.NotNull(customerCreatedMessage.Customer);

            Customer customer = customerCreatedMessage.Customer;

            SetCustomerIdAction setCustomerIdAction = new SetCustomerIdAction {
                CustomerId = customer.Id
            };
            Response <Cart> cartResponse = await _client.Carts().UpdateCartAsync(_testCarts[0], setCustomerIdAction);

            Assert.IsTrue(cartResponse.Success);

            _testCarts[0] = cartResponse.Result;
            Assert.NotNull(_testCarts[0].Id);
            Assert.AreEqual(_testCarts[0].CustomerId, customer.Id);

            setCustomerIdAction = new SetCustomerIdAction();
            cartResponse        = await _client.Carts().UpdateCartAsync(_testCarts[0], setCustomerIdAction);

            Assert.IsTrue(cartResponse.Success);

            _testCarts[0] = cartResponse.Result;
            Assert.NotNull(_testCarts[0].Id);
            Assert.AreNotEqual(_testCarts[0].CustomerId, customer.Id);

            await _client.Customers().DeleteCustomerAsync(customer);
        }
        /// <summary>
        /// Test setup
        /// </summary>
        public CartManagerTest()
        {
            _client = new Client(Helper.GetConfiguration());

            Task <Response <Project.Project> > projectTask = _client.Project().GetProjectAsync();

            projectTask.Wait();
            Assert.True(projectTask.Result.Success);
            _project = projectTask.Result.Result;

            Assert.True(_project.Languages.Count > 0);
            Assert.True(_project.Currencies.Count > 0);

            _testCustomers = new List <Customer>();
            _testCarts     = new List <Cart>();
            _testCartsExternalAmountTaxMode = new List <Cart>();

            for (int i = 0; i < 5; i++)
            {
                CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
                Task <Response <CustomerCreatedMessage> > customerTask = _client.Customers().CreateCustomerAsync(customerDraft);
                customerTask.Wait();
                Assert.True(customerTask.Result.Success);

                CustomerCreatedMessage customerCreatedMessage = customerTask.Result.Result;
                Assert.NotNull(customerCreatedMessage.Customer);
                Assert.NotNull(customerCreatedMessage.Customer.Id);

                _testCustomers.Add(customerCreatedMessage.Customer);

                CartDraft cartDraft = Helper.GetTestCartDraft(_project, customerCreatedMessage.Customer.Id);
                Task <Response <Cart> > cartTask = _client.Carts().CreateCartAsync(cartDraft);
                cartTask.Wait();
                Assert.True(cartTask.Result.Success);
                Cart cart = cartTask.Result.Result;
                Assert.NotNull(cart.Id);

                _testCarts.Add(cart);

                cartDraft         = Helper.GetTestCartDraft(_project, customerCreatedMessage.Customer.Id);
                cartDraft.TaxMode = TaxMode.ExternalAmount;
                cartTask          = _client.Carts().CreateCartAsync(cartDraft);
                cartTask.Wait();
                Assert.NotNull(cartTask.Result);
                Assert.True(cartTask.Result.Success, "CreateCartAsync failed");
                cart = cartTask.Result.Result;
                Assert.True(cart.TaxMode == TaxMode.ExternalAmount, string.Format("Cart created using ExternalAmount TaxMode failed - TaxMode: {0}", cart.TaxMode));
                Assert.NotNull(cart.Id);
                Console.Error.WriteLine(string.Format("CartManagerTest - Information Only - Init TestCartDraft TaxMode: {0}", cartDraft.TaxMode == null ? "(default)" : cart.TaxMode.ToString()));

                _testCartsExternalAmountTaxMode.Add(cart);
            }

            ProductTypeDraft productTypeDraft = Helper.GetTestProductTypeDraft();
            Task <Response <ProductType> > testProductTypeTask = _client.ProductTypes().CreateProductTypeAsync(productTypeDraft);

            testProductTypeTask.Wait();
            Assert.True(testProductTypeTask.Result.Success);
            _testProductType = testProductTypeTask.Result.Result;
            Assert.NotNull(_testProductType.Id);

            TaxCategoryDraft taxCategoryDraft = Helper.GetTestTaxCategoryDraft(_project);
            Task <Response <TaxCategory> > taxCategoryTask = _client.TaxCategories().CreateTaxCategoryAsync(taxCategoryDraft);

            taxCategoryTask.Wait();
            Assert.True(taxCategoryTask.Result.Success);
            _testTaxCategory = taxCategoryTask.Result.Result;
            Assert.NotNull(_testTaxCategory.Id);

            Task <Response <ZoneQueryResult> > zoneQueryResultTask = _client.Zones().QueryZonesAsync();

            zoneQueryResultTask.Wait();
            Assert.True(zoneQueryResultTask.Result.Success);

            if (zoneQueryResultTask.Result.Result.Results.Count > 0)
            {
                _testZone        = zoneQueryResultTask.Result.Result.Results[0];
                _createdTestZone = false;
            }
            else
            {
                ZoneDraft zoneDraft = Helper.GetTestZoneDraft();
                Task <Response <Zone> > zoneTask = _client.Zones().CreateZoneAsync(zoneDraft);
                zoneTask.Wait();
                Assert.True(zoneTask.Result.Success);
                _testZone        = zoneTask.Result.Result;
                _createdTestZone = true;
            }

            Assert.NotNull(_testZone.Id);

            foreach (string country in _project.Countries)
            {
                Location location =
                    _testZone.Locations
                    .Where(l => l.Country.Equals(country, StringComparison.OrdinalIgnoreCase))
                    .FirstOrDefault();

                if (location == null)
                {
                    location         = new Location();
                    location.Country = country;

                    AddLocationAction       addLocationAction = new AddLocationAction(location);
                    Task <Response <Zone> > updateZoneTask    = _client.Zones().UpdateZoneAsync(_testZone, addLocationAction);
                    updateZoneTask.Wait();
                    Assert.True(updateZoneTask.Result.Success);
                    _testZone = updateZoneTask.Result.Result;
                }
            }

            Assert.NotNull(_testZone.Locations.Count > 0);

            ShippingMethodDraft shippingMethodDraft = Helper.GetTestShippingMethodDraft(_project, _testTaxCategory, _testZone);
            Task <Response <ShippingMethod> > shippingMethodTask = _client.ShippingMethods().CreateShippingMethodAsync(shippingMethodDraft);

            shippingMethodTask.Wait();
            Assert.True(shippingMethodTask.Result.Success);
            _testShippingMethod = shippingMethodTask.Result.Result;

            Assert.NotNull(_testShippingMethod.Id);

            ProductDraft productDraft = Helper.GetTestProductDraft(_project, _testProductType.Id, _testTaxCategory.Id);
            Task <Response <Product> > testProductTask = _client.Products().CreateProductAsync(productDraft);

            testProductTask.Wait();
            Assert.True(testProductTask.Result.Success);
            _testProduct = testProductTask.Result.Result;

            Assert.NotNull(_testProduct.Id);

            PaymentDraft paymentDraft = Helper.GetTestPaymentDraft(_project, _testCustomers[0].Id);
            Task <Response <Payment> > paymentTask = _client.Payments().CreatePaymentAsync(paymentDraft);

            paymentTask.Wait();
            Assert.True(paymentTask.Result.Success);
            _testPayment = paymentTask.Result.Result;

            Assert.NotNull(_testPayment.Id);

            TypeDraft typeDraft = Helper.GetTypeDraft(_project);
            Task <Response <Type> > typeTask = _client.Types().CreateTypeAsync(typeDraft);

            typeTask.Wait();
            Assert.True(typeTask.Result.Success);
            _testType = typeTask.Result.Result;
        }
Beispiel #6
0
        public void Init()
        {
            _client = new Client(Helper.GetConfiguration());

            Task <Response <Project.Project> > projectTask = _client.Project().GetProjectAsync();

            projectTask.Wait();
            Assert.IsTrue(projectTask.Result.Success);
            _project = projectTask.Result.Result;

            _testCustomers = new List <Customer>();

            for (int i = 0; i < 5; i++)
            {
                CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
                Task <Response <CustomerCreatedMessage> > customerTask = _client.Customers().CreateCustomerAsync(customerDraft);
                customerTask.Wait();
                Assert.IsTrue(customerTask.Result.Success);

                CustomerCreatedMessage customerCreatedMessage = customerTask.Result.Result;
                Assert.NotNull(customerCreatedMessage.Customer);
                Assert.NotNull(customerCreatedMessage.Customer.Id);

                _testCustomers.Add(customerCreatedMessage.Customer);
            }

            _testCarts = new List <Cart>();
            Task <Response <Cart> > cartTask;

            for (int i = 0; i < 5; i++)
            {
                CartDraft cartDraft = Helper.GetTestCartDraft(_project, _testCustomers[i].Id);
                cartTask = _client.Carts().CreateCartAsync(cartDraft);
                cartTask.Wait();
                Assert.IsTrue(cartTask.Result.Success);

                Cart cart = cartTask.Result.Result;
                Assert.NotNull(cart.Id);

                _testCarts.Add(cart);
            }

            ProductTypeDraft productTypeDraft = Helper.GetTestProductTypeDraft();
            Task <Response <ProductType> > productTypeTask = _client.ProductTypes().CreateProductTypeAsync(productTypeDraft);

            productTypeTask.Wait();
            Assert.IsTrue(productTypeTask.Result.Success);

            _testProductType = productTypeTask.Result.Result;
            Assert.NotNull(_testProductType.Id);

            TaxCategoryDraft taxCategoryDraft = Helper.GetTestTaxCategoryDraft(_project);
            Task <Response <TaxCategory> > taxCategoryTask = _client.TaxCategories().CreateTaxCategoryAsync(taxCategoryDraft);

            taxCategoryTask.Wait();
            Assert.IsTrue(taxCategoryTask.Result.Success);

            _testTaxCategory = taxCategoryTask.Result.Result;
            Assert.NotNull(_testTaxCategory.Id);

            Task <Response <ZoneQueryResult> > zoneQueryResultTask = _client.Zones().QueryZonesAsync();

            zoneQueryResultTask.Wait();

            if (zoneQueryResultTask.Result.Success && zoneQueryResultTask.Result.Result.Results.Count > 0)
            {
                _testZone        = zoneQueryResultTask.Result.Result.Results[0];
                _createdTestZone = false;
            }
            else
            {
                ZoneDraft zoneDraft = Helper.GetTestZoneDraft();
                Task <Response <Zone> > zoneTask = _client.Zones().CreateZoneAsync(zoneDraft);
                zoneTask.Wait();
                Assert.IsTrue(zoneTask.Result.Success);

                _testZone        = zoneTask.Result.Result;
                _createdTestZone = true;
            }

            Assert.NotNull(_testZone.Id);

            ShippingMethodDraft shippingMethodDraft = Helper.GetTestShippingMethodDraft(_project, _testTaxCategory, _testZone);
            Task <Response <ShippingMethod> > shippingMethodTask = _client.ShippingMethods().CreateShippingMethodAsync(shippingMethodDraft);

            shippingMethodTask.Wait();
            Assert.IsTrue(shippingMethodTask.Result.Success);

            _testShippingMethod = shippingMethodTask.Result.Result;
            Assert.NotNull(_testShippingMethod.Id);

            ProductDraft productDraft = Helper.GetTestProductDraft(_project, _testProductType.Id, _testTaxCategory.Id);
            Task <Response <Product> > productTask = _client.Products().CreateProductAsync(productDraft);

            productTask.Wait();
            Assert.IsTrue(productTask.Result.Success);

            _testProduct = productTask.Result.Result;
            Assert.NotNull(_testProduct.Id);

            int quantity = 1;
            AddLineItemAction addLineItemAction = new AddLineItemAction(_testProduct.Id, _testProduct.MasterData.Current.MasterVariant.Id);

            addLineItemAction.Quantity = quantity;
            cartTask = _client.Carts().UpdateCartAsync(_testCarts[0], addLineItemAction);
            cartTask.Wait();
            Assert.IsTrue(cartTask.Result.Success);

            _testCarts[0] = cartTask.Result.Result;
            Assert.NotNull(_testCarts[0].Id);
            Assert.NotNull(_testCarts[0].LineItems);
            Assert.AreEqual(_testCarts[0].LineItems.Count, 1);
            Assert.AreEqual(_testCarts[0].LineItems[0].ProductId, _testProduct.Id);
            Assert.AreEqual(_testCarts[0].LineItems[0].Variant.Id, _testProduct.MasterData.Current.MasterVariant.Id);
            Assert.AreEqual(_testCarts[0].LineItems[0].Quantity, quantity);

            OrderFromCartDraft       orderFromCartDraft = Helper.GetTestOrderFromCartDraft(_testCarts[0]);
            Task <Response <Order> > orderTask          = _client.Orders().CreateOrderFromCartAsync(orderFromCartDraft);

            orderTask.Wait();
            Assert.IsTrue(orderTask.Result.Success);

            _testOrder = orderTask.Result.Result;
            Assert.NotNull(_testOrder.Id);

            cartTask = _client.Carts().GetCartByIdAsync(_testCarts[0].Id);
            cartTask.Wait();
            Assert.IsTrue(cartTask.Result.Success);

            _testCarts[0] = cartTask.Result.Result;
            Assert.NotNull(_testCarts[0].Id);
        }