def test_correctly_allocates_stock(self): factories.create_order(basket=self.basket) record = StockRecord.objects.get(product=self.product) self.assertEqual(5, record.num_in_stock) self.assertEqual(1, record.num_allocated) self.assertEqual(4, record.net_stock_level)
def test_downloads_to_csv_without_error(self): address = ShippingAddressFactory() create_order(shipping_address=address) page = self.get(reverse('dashboard:order-list')) form = page.forms['orders_form'] form['selected_order'].checked = True form.submit('download_selected')
def test_downloads_to_csv_without_error(self): address = get(ShippingAddress) create_order(shipping_address=address) page = self.get(reverse("dashboard:order-list")) form = page.forms["orders_form"] form["selected_order"].checked = True form.submit("download_selected")
def test_raises_alert_when_threshold_is_reached(self): self.set_threshold(5) factories.create_order(basket=self.basket) alerts = StockAlert.objects.filter( stockrecord=self.stockrecord) self.assertEqual(1, len(alerts))
def setUp(self): self.order = factories.create_order() self.handler = EventHandler() basket = factories.create_basket(empty=True) add_product(basket, D('10.00'), 5) self.order = factories.create_order(basket=basket) self.settled = models.PaymentEventType.objects.create( name='Settled')
def setUp(self): self.order = create_order() self.handler = EventHandler() basket = Basket.objects.create() basket.add_product(create_product(price=D('10.00')), 5) self.order = create_order(basket=basket) self.settled = models.PaymentEventType.objects.create( name='Settled')
def test_includes_hourly_report_with_orders(self): create_order(total_incl_tax=D('34.05'), total_excl_tax=D('34.05')) create_order(total_incl_tax=D('21.90'), total_excl_tax=D('21.90')) report = IndexView().get_hourly_report() self.assertEquals(len(report['order_total_hourly']), 12) self.assertEquals(len(report['y_range']), 11) self.assertEquals(report['max_revenue'], D('60'))
def test_only_raises_an_alert_once(self): self.set_threshold(5) StockAlert.objects.create(stockrecord=self.stockrecord, threshold=10) factories.create_order(basket=self.basket) alerts = StockAlert.objects.filter( stockrecord=self.stockrecord) self.assertEqual(1, len(alerts))
def setUp(self): super(UpdateOrderCommandTests, self).setUp() self.correct_order = factories.create_order() self.affected_order = factories.create_order(number=self.ORDER_NUMBER) self.affected_order.total_incl_tax = 98.0 self.affected_order.total_excl_tax = 98.0 self.affected_order.save() LinePrice.objects.filter(order=self.affected_order).update(quantity=2) PaymentEventQuantity.objects.filter(line__in=self.affected_order.lines.all()).update(quantity=2) BasketLine.objects.filter(basket=self.affected_order.basket).update(quantity=2)
def test_includes_hourly_report_with_orders(self): create_order(total=prices.Price('GBP', excl_tax=D('34.05'), tax=D('0.00'))) create_order(total=prices.Price('GBP', excl_tax=D('21.90'), tax=D('0.00'))) report = IndexView().get_hourly_report(Order.objects.all()) self.assertEqual(len(report['order_total_hourly']), 12) self.assertEqual(len(report['y_range']), 11) self.assertEqual(report['max_revenue'], D('60'))
def test_non_course_order(self): """ Refunds should NOT be created for orders with no line items related to courses. """ Refund.objects.all().delete() factories.create_order(user=self.user) self.assertEqual(Refund.objects.count(), 0) data = self._get_data(self.user.username, self.course_id) response = self.client.post(self.path, data, JSON_CONTENT_TYPE) self.assert_ok_response(response) self.assertEqual(Refund.objects.count(), 0)
def test_with_other_users_orders(self): """ The view should only return orders for the authenticated users. """ other_user = self.create_user() factories.create_order(user=other_user) response = self.client.get(self.path, HTTP_AUTHORIZATION=self.token) self.assert_empty_result_response(response) order = factories.create_order(user=self.user) response = self.client.get(self.path, HTTP_AUTHORIZATION=self.token) content = json.loads(response.content) self.assertEqual(content['count'], 1) self.assertEqual(content['results'][0]['number'], unicode(order.number))
def setUp(self): super(DeleteOrderedBasketsCommandTests, self).setUp() # Create baskets with and without orders self.orders = [factories.create_order() for __ in range(0, 2)] self.unordered_baskets = [factories.BasketFactory() for __ in range(0, 3)] # Create invoiced baskets. self.invoiced_orders = [factories.create_order() for __ in range(0, 2)] self.invoiced_baskets = [order.basket for order in self.invoiced_orders] for order in self.invoiced_orders: Invoice.objects.create(basket=order.basket, order=order)
def test_closes_open_alert(self): self.set_threshold(5) factories.create_order(basket=self.basket) alert = StockAlert.objects.get(stockrecord=self.stockrecord) self.assertEqual(StockAlert.OPEN, alert.status) # Restock product self.stockrecord.num_in_stock = 15 self.stockrecord.save() alert = StockAlert.objects.get(stockrecord=self.stockrecord) self.assertEqual(StockAlert.CLOSED, alert.status)
def test_username_filter_with_staff(self): """ Verify the staff user can filter data by username.""" # create two orders for different users order = factories.create_order(user=self.user) other_user = self.create_user() other_order = factories.create_order(user=other_user) requester = self.create_user(is_staff=True) self.client.login(email=requester.email, password=self.password) self.assert_list_with_username_filter(self.user, order) self.assert_list_with_username_filter(other_user, other_order)
def test_closes_open_alert(self): # Set threshold as same as current level self.set_threshold(5) factories.create_order(basket=self.basket) alert = StockAlert.objects.get(stockrecord=self.stockrecord) self.assertEqual(StockAlert.OPEN, alert.status) # Restock product self.stockrecord.num_in_stock = 15 self.stockrecord.save() alert = StockAlert.objects.get(stockrecord=self.stockrecord) self.assertEqual(StockAlert.CLOSED, alert.status) self.assertIsNotNone(alert.date_closed)
def test_redirects_to_detail_page(self): order = create_order() page = self.get(reverse('dashboard:order-list')) form = page.forms['search_form'] form['order_number'] = order.number response = form.submit() self.assertEqual(http_client.FOUND, response.status_code)
def _dummy_order_data(status=ORDER.COMPLETE): """ Creates dummy order data for testing.""" order = create_order() order.status = status order.save() order.basket.freeze() return order.basket
def test_gets_404_when_using_incorrect_hash(self): order = create_order() path = reverse('customer:anon-order', kwargs={'order_number': order.number, 'hash': 'bad'}) response = self.app.get(path, status="*") self.assertEqual(http_client.NOT_FOUND, response.status_code)
def test_track_completed_discounted_order_with_voucher_with_offer(self): with mock.patch( 'ecommerce.extensions.checkout.signals.track_segment_event' ) as mock_track: # Orders may be discounted by a fixed value fixed_benefit = 5.00 offer_discount = 6 product = ProductFactory(categories=[], stockrecords__price_currency='USD') _range = factories.RangeFactory(products=[product], ) voucher, product = prepare_voucher(_range=_range, benefit_value=fixed_benefit, benefit_type=Benefit.FIXED) factories.ConditionalOfferFactory( offer_type=ConditionalOffer.SITE, benefit=factories.BenefitFactory(range=_range, value=offer_discount), condition=factories.ConditionFactory(type=Condition.COVERAGE, value=1, range=_range)) basket = factories.BasketFactory(owner=self.user, site=self.site) basket.add_product(product) basket.vouchers.add(voucher) Applicator().apply(basket, user=basket.owner, request=self.request) order = factories.create_order(basket=basket, user=self.user) track_completed_order(None, order) properties = self._generate_event_properties(order, voucher) mock_track.assert_called_once_with(order.site, order.user, 'Order Completed', properties)
def test_creates_shipments_for_multiple_addresses(self): second_address = ShippingAddress.objects.create( first_name="test man's friend", line1="1 Random Way", line4="Spooky Village", state="RI", postcode="56789", country=Country.objects.all()[0], ) addresses = [self.address, second_address] order = create_order(basket=self.basket, shipping_address=self.address) order.get_fulfillment_addresses = mock.Mock(return_value=addresses) def get_lines_for_address(address): if address == self.address: return order.lines.all()[:1] return order.lines.all()[1:] order.get_lines_for_address = get_lines_for_address mws_orders = self.creator.create_fulfillment_order(order) self.assertEquals(FulfillmentOrder.objects.count(), 2) for mws_order, address in zip(mws_orders, addresses): self.assertEquals(mws_order.status, mws_order.UNSUBMITTED) self.assertEquals(mws_order.shipping_address.id, address.id)
def setUp(self): Line.pipeline = {'A': ('B', 'C'), 'B': ('C',)} self.order = create_order() self.line = self.order.lines.all()[0] self.line.status = 'A' self.line.save()
def test_dispatch_order_messages(self): email = '*****@*****.**' user = User.objects.create_user('testuser', email, 'somesimplepassword') order = create_order(number='12345', user=user) self.assertFalse(order.is_anonymous) self._dispatch_order_messages(order_number='12345', order=order, email=email)
def setUp(self): User = get_user_model() self.user = User.objects.create_user( username='******', email='*****@*****.**', password='******' ) self.product_class = factories.ProductClassFactory( name='Seat', requires_shipping=False, track_stock=False ) self.course = factories.ProductFactory( structure='parent', upc='001', title='EdX DemoX Course', product_class=self.product_class ) self.seat = factories.ProductFactory( structure='child', upc='002', title='Seat in EdX DemoX Course with Honor Certificate', product_class=self.product_class, parent=self.course ) for stock_record in self.seat.stockrecords.all(): stock_record.price_currency = 'USD' stock_record.save() basket = factories.create_basket(empty=True) basket.add_product(self.seat, 1) self.order = factories.create_order(number=1, basket=basket, user=self.user) # Move the order from 'Open' to 'Paid' so fulfillment can be completed. self.order.set_status(ORDER.BEING_PROCESSED) self.order.set_status(ORDER.PAID)
def test_can_be_created_with_an_offer(self): offer = create_offer() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), offer_id=offer.id) self.assertEqual(offer.id, discount.offer.id) self.assertEqual(offer.name, discount.offer_name)
def test_can_see_order_status(self): order = create_order() path = reverse('customer:anon-order', kwargs={'order_number': order.number, 'hash': order.verification_hash()}) response = self.app.get(path) self.assertEqual(http_client.OK, response.status_code)
def test_track_completed_discounted_order_with_offer(self): """ An event including a discount but no coupon should be sent to Segment""" with mock.patch( 'ecommerce.extensions.checkout.signals.track_segment_event' ) as mock_track: # Orders may be discounted by a fixed value offer_discount = 5 product = ProductFactory(categories=[], stockrecords__price_currency='USD') _range = factories.RangeFactory(products=[product], ) site_offer = factories.ConditionalOfferFactory( offer_type=ConditionalOffer.SITE, benefit=factories.BenefitFactory(range=_range, value=offer_discount), condition=factories.ConditionFactory(type=Condition.COVERAGE, value=1, range=_range)) basket = factories.BasketFactory(owner=self.user, site=self.site) basket.add_product(product) Applicator().apply_offers(basket, [site_offer]) order = factories.create_order(basket=basket, user=self.user) track_completed_order(None, order) properties = self._generate_event_properties(order) mock_track.assert_called_once_with(order.site, order.user, 'Order Completed', properties)
def test_can_be_created_with_a_voucher(self): voucher = create_voucher() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), voucher_id=voucher.id) self.assertEqual(voucher.id, discount.voucher.id) self.assertEqual(voucher.code, discount.voucher_code)
def test_persist_taxation_details(self, get_transport): """Place an order with normal taxes""" basket = self.prepare_basket() to_address = self.get_to_address() resp = self._get_cch_response_normal( basket.all_lines()[0].id ) get_transport.return_value = self._build_transport_with_reply(resp) # This should call CCH and save tax details in the DB order = factories.create_order(basket=basket, shipping_address=to_address) # Make sure we have an order taxation object self.assertEqual(order.taxation.transaction_id, 40043) self.assertEqual(order.taxation.transaction_status, 4) self.assertEqual(order.taxation.total_tax_applied, D('0.89')) # Make sure we have an line taxation objects for line in order.lines.all(): self.assertEqual(line.taxation.country_code, 'US') self.assertEqual(line.taxation.state_code, 'NY') self.assertEqual(line.taxation.total_tax_applied, D('0.89')) self.assertEqual(line.taxation.details.count(), 3) for detail in line.taxation.details.all(): self.assertIn('AuthorityName', detail.data) self.assertIn('TaxName', detail.data) self.assertIn('TaxRate', detail.data) self.assertTrue(float(detail.data['TaxRate']) > 0) self.assertIn('TaxableAmount', detail.data) self.assertIn('TaxableQuantity', detail.data)
def test_allows_date_placed_to_be_changed_and_set_explicitly(self): order = create_order(number='100003') tzinfo = timezone.get_current_timezone() order.date_placed = datetime(2012, 8, 11, 16, 14, tzinfo=tzinfo) order.save() self.assertEqual(order.date_placed, datetime(2012, 8, 11, 16, 14, tzinfo=tzinfo))
def setUp(self): self.order = create_order() self.line = self.order.lines.all()[0] self.url = reverse('dashboard:order-line-detail', kwargs={'number': self.order.number, 'line_id': self.line.id}) super(LineDetailTests, self).setUp()
def setUp(self): """ Creates two orders. order_in has self.user in it's partner users list. """ super(PermissionBasedDashboardOrderTestsBase, self).setUp() self.address = G(ShippingAddress) self.basket_in = create_basket() self.basket_out = create_basket() # replace partner with one that has the user in it's users list self.partner_in = G(Partner, users=[self.user]) stockrecord = self.basket_in.lines.all()[0].stockrecord stockrecord.partner = self.partner_in stockrecord.save() self.order_in = create_order(basket=self.basket_in, shipping_address=self.address) self.order_out = create_order(basket=self.basket_out, shipping_address=self.address)
def setUp(self): super(CouponFulfillmentModuleTest, self).setUp() coupon = self.create_coupon() user = UserFactory() basket = BasketFactory() basket.add_product(coupon, 1) self.order = factories.create_order(number=1, basket=basket, user=user)
def test_can_be_created_with_a_voucher_and_specidied_voucher_code(self): voucher = create_voucher() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), voucher_id=voucher.id, voucher_code="anothercode") self.assertEqual(voucher.id, discount.voucher.id) self.assertEqual('anothercode', discount.voucher_code)
def setUp(self): super(InvoiceCommandTests, self).setUp() coupon_pc = factories.ProductClassFactory(name='Coupon') self.product = factories.ProductFactory(product_class=coupon_pc) self.basket = factories.BasketFactory() self.basket.add_product(self.product, 1) self.order = factories.create_order(basket=self.basket) self.invoice = Invoice.objects.create(order=self.order)
def _create_order(self, price, mode='verified'): seat = self.course.create_or_update_seat(mode, False, price, self.partner, None) basket = BasketFactory() basket.add_product(seat, 1) order = create_order(number=1, basket=basket, user=self.user, site=self.site) order.total_excl_tax = price return seat, order
def test_can_be_created_with_an_offer_and_specified_offer_name(self): offer = create_offer(name="My offer") order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), offer_id=offer.id, offer_name="Your offer") self.assertEqual(offer.id, discount.offer.id) self.assertEqual("Your offer", discount.offer_name)
def test_can_be_created_without_offer_or_voucher(self): order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00')) self.assertTrue(discount.voucher is None) self.assertTrue(discount.offer is None) self.assertEqual(discount.description(), u'')
def test_allows_date_placed_to_be_changed_and_set_explicitly(self): order = create_order(number='100003') tzinfo = timezone.get_current_timezone() order.date_placed = datetime(2012, 8, 11, 16, 14, tzinfo=tzinfo) order.save() self.assertTupleEqual(self.get_date_tuple(order.date_placed), (2012, 8, 11, 16, 14))
def setUp(self): super().setUp() # ensures that initial statuses are as expected self.order = create_order() self.event_type = PaymentEventType.objects.create(name='foo') url = reverse('dashboard:order-detail', kwargs={'number': self.order.number}) self.page = self.get(url)
def test_can_see_order_status(self): order = create_order() path = reverse('customer:anon-order', kwargs={ 'order_number': order.number, 'hash': order.verification_hash() }) response = self.app.get(path) self.assertEqual(http_client.OK, response.status_code)
def setUp(self): basket = create_basket(empty=True) add_product(basket, D('10.00'), 4) self.order = create_order(number='100002', basket=basket) self.line = self.order.lines.all()[0] self.order_placed, __ = ShippingEventType.objects.get_or_create( code='order_placed', name='Order placed') self.dispatched, __ = ShippingEventType.objects.get_or_create( code='dispatched', name='Dispatched')
def setUp(self): """ Creates two orders. order_in has self.user in it's partner users list. """ super().setUp() self.address = ShippingAddressFactory() self.basket_in = create_basket() self.basket_out = create_basket() # replace partner with one that has the user in it's users list self.partner_in = PartnerFactory(users=[self.user]) stockrecord = self.basket_in.lines.all()[0].stockrecord stockrecord.partner = self.partner_in stockrecord.save() self.order_in = create_order(basket=self.basket_in, shipping_address=self.address) self.order_out = create_order(basket=self.basket_out, shipping_address=self.address)
def test_set_status_signal_creates_a_order_status_change_object(self): self.order = create_order(status='PENDING') self.order.set_status('SHIPPED') order_status_change = self.order.status_changes.first() self.assertEqual(self.order.status_changes.count(), 1) self.assertEqual(order_status_change.old_status, 'PENDING') self.assertEqual(order_status_change.new_status, 'SHIPPED')
def test_gets_404_when_using_incorrect_hash(self): order = create_order() path = reverse('customer:anon-order', kwargs={ 'order_number': order.number, 'hash': 'bad' }) response = self.app.get(path, status="*") self.assertEqual(http_client.NOT_FOUND, response.status_code)
def test_staff_superuser(self, is_staff, is_superuser): """ The view should return all orders for when authenticating as a staff member or superuser. """ admin_user = self.create_user(is_staff=is_staff, is_superuser=is_superuser) order = factories.create_order(user=self.user) response = self.client.get(self.path, HTTP_AUTHORIZATION=self.generate_jwt_token_header(admin_user)) content = json.loads(response.content) self.assertEqual(content['count'], 1) self.assertEqual(content['results'][0]['number'], unicode(order.number))
def setUp(self): super(TestInvoice, self).setUp() self.user = UserFactory() self.order = create_order(number='000042', user=self.user) LegalEntityAddressFactory( legal_entity=LegalEntityFactory(), country=CountryFactory(), )
def test_dispatch_anonymous_order_messages(self): order = create_order(number='12346', guest_email='*****@*****.**') self.assertTrue(order.is_anonymous) self._dispatch_order_messages( order_number='12346', order=order, email='*****@*****.**', )
def setUp(self): self.order = create_order() self.line = self.order.lines.all()[0] self.url = reverse('dashboard:order-line-detail', kwargs={ 'number': self.order.number, 'line_id': self.line.id }) super().setUp()
def test_facade(self): request = RequestFactory().get("/api/checkout/") order = create_order() result = screen_transaction(request, order) self.assertEqual(result.screen_type, "Dummy") self.assertEqual(result.order, order) self.assertEqual(result.decision, "ACCEPT") self.assertEqual(result.message, "Transaction accepted.")
def test_facade(self): request = RequestFactory().get('/api/checkout/') order = create_order() result = screen_transaction(request, order) self.assertEqual(result.screen_type, 'Dummy') self.assertEqual(result.order, order) self.assertEqual(result.decision, 'ACCEPT') self.assertEqual(result.message, 'Transaction accepted.')
def test_creates_shipments_for_single_address(self): order = create_order(basket=self.basket, shipping_address=self.address) self.creator.create_fulfillment_order(order) mws_orders = FulfillmentOrder.objects.all() self.assertEquals(len(mws_orders), 1) mws_order = mws_orders[0] self.assertEquals(mws_order.status, mws_order.UNSUBMITTED) self.assertEquals(mws_order.shipping_address.id, self.address.id)
def test_str_method_of_invoice_model_instance(self): """ Checks correct representation of `Invoice` instance (e.g. in invoices list in the admin site). """ order_number = '0000042' order = create_order(number=order_number, user=self.user) invoice = InvoiceCreator().create_invoice(order) assert str(invoice) == 'Invoice #{} for order #{}'.format(invoice.number, order_number)
def test_contains_coupon(self): self.assertFalse(self.order.contains_coupon) product = factories.create_product( product_class=COUPON_PRODUCT_CLASS_NAME) basket = factories.create_basket(empty=True) factories.create_stockrecord(product, num_in_stock=1) basket.add_product(product) order = factories.create_order(basket=basket) self.assertTrue(order.contains_coupon)
def test_with_orders(self): """ The view should return a list of the user's orders, sorted reverse chronologically. """ order = factories.create_order(user=self.user) response = self.client.get(self.path, HTTP_AUTHORIZATION=self.token) self.assertEqual(response.status_code, 200) content = json.loads(response.content) self.assertEqual(content['count'], 1) self.assertEqual(content['results'][0]['number'], unicode(order.number)) # Test ordering order_2 = factories.create_order(user=self.user) response = self.client.get(self.path, HTTP_AUTHORIZATION=self.token) self.assertEqual(response.status_code, 200) content = json.loads(response.content) self.assertEqual(content['count'], 2) self.assertEqual(content['results'][0]['number'], unicode(order_2.number)) self.assertEqual(content['results'][1]['number'], unicode(order.number))
def setUp(self): basket = create_basket(empty=True) add_product(basket, D('10.00'), 4) self.order = create_order(number='100002', basket=basket) self.line = self.order.lines.all()[0] self.shipped, __ = ShippingEventType.objects.get_or_create( name='Shipped') self.returned, __ = ShippingEventType.objects.get_or_create( name='Returned')