Remove obsolete management commands.

ecommerce/coupons/management/commands/populate_coupon_categories.py

-import logging
-
-from django.core.management import BaseCommand
-from oscar.core.loading import get_model
-
-Category = get_model('catalogue', 'Category')
-Product = get_model('catalogue', 'Product')
-ProductCategory = get_model('catalogue', 'ProductCategory')
-
-logger = logging.getLogger(__name__)
-
-
-class Command(BaseCommand):
-    """ Populate the category field for coupons that do not have a category. """
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
-    logger.addHandler(ch)
-
-    def handle(self, *args, **options):
-        support_other_cat = Category.objects.get(name='Support-Other')
-        for coupon in Product.objects.filter(product_class__name='Coupon'):
-            try:
-                ProductCategory.objects.get(product=coupon)
-            except ProductCategory.DoesNotExist:
-                ProductCategory.objects.create(
-                    product=coupon,
-                    category=support_other_cat
-                )
-                logger.info('Added category for coupon [%s]', coupon.id)

ecommerce/coupons/tests/test_command.py

-from django.core.management import call_command
-from oscar.core.loading import get_model
-
-from ecommerce.coupons.tests.mixins import CouponMixin
-from ecommerce.tests.testcases import TestCase
-
-Category = get_model('catalogue', 'Category')
-ProductCategory = get_model('catalogue', 'ProductCategory')
-
-
-class TestCouponCommand(CouponMixin, TestCase):
-    """ Test coupon populate_coupon_category command. """
-    def setUp(self):
-        super(TestCouponCommand, self).setUp()
-        self.filler_category, __ = Category.objects.get_or_create(name='Support-Other', defaults={'depth': 1})
-        self.coupon = self.create_coupon()
-
-    def test_add_category_to_coupon(self):
-        """ Verify the correct category is assigned to a coupon without category. """
-        ProductCategory.objects.filter(product=self.coupon).delete()
-        self.assertEqual(ProductCategory.objects.count(), 0)
-
-        call_command('populate_coupon_categories')
-        self.assertEqual(ProductCategory.objects.count(), 1)
-        self.assertEqual(ProductCategory.objects.get(product=self.coupon).category, self.filler_category)
-
-    def test_coupon_with_category_unaffected(self):
-        """ Verify coupon with category is unchanged after running command. """
-        self.assertEqual(ProductCategory.objects.count(), 1)
-        category = ProductCategory.objects.get(product=self.coupon).category
-
-        call_command('populate_coupon_categories')
-        self.assertEqual(ProductCategory.objects.count(), 1)
-        self.assertEqual(ProductCategory.objects.get(product=self.coupon).category, category)

ecommerce/extensions/offer/management/commands/set_max_applications_to_none.py

-""" Changes ConditionalOffer max_global_applications for single use vouchers from one to None. """
-
-from __future__ import unicode_literals
-from django.core.management import BaseCommand
-from oscar.core.loading import get_model
-
-ConditionalOffer = get_model('offer', 'ConditionalOffer')
-
-
-class Command(BaseCommand):
-    def handle(self, *args, **options):
-        offers = ConditionalOffer.objects.filter(max_global_applications=1, vouchers__usage='Single use')
-        if offers:
-            for offer in offers:
-                self.stdout.write(
-                    'Setting max_global_applications field to None for ConditionalOffer [{}]...'.format(offer)
-                )
-                offer.max_global_applications = None
-                offer.save()
-            self.stdout.write('Done.')
-        else:
-            self.stdout.write('Nothing to do here.')

ecommerce/extensions/offer/tests/test_commands.py

-from __future__ import unicode_literals
-from StringIO import StringIO
-
-from django.core.management import call_command
-from oscar.core.loading import get_model
-from oscar.test import factories
-
-from ecommerce.tests.testcases import TestCase
-
-ConditionalOffer = get_model('offer', 'ConditionalOffer')
-Voucher = get_model('voucher', 'Voucher')
-
-
-class SetMaxApplicationsToNoneCommandTest(TestCase):
-    command = 'set_max_applications_to_none'
-    filter_condition = {
-        'max_global_applications': 1,
-        'vouchers__usage': Voucher.SINGLE_USE
-    }
-
-    def call_command_and_return_output(self):
-        output = StringIO()
-        call_command(self.command, stdout=output)
-        return output
-
-    def test_command_on_one_sample(self):
-        """Verify the command changes single use vouchers offer with max_global_applications value set to one."""
-        offer = factories.ConditionalOfferFactory(max_global_applications=1)
-        voucher = factories.VoucherFactory(usage=Voucher.SINGLE_USE)
-        voucher.offers.add(offer)
-        self.assertEqual(ConditionalOffer.objects.filter(**self.filter_condition).count(), 1)
-
-        output = self.call_command_and_return_output()
-        actual_output = output.getvalue().strip()
-
-        self.assertTrue(actual_output.startswith(
-            'Setting max_global_applications field to None for ConditionalOffer [{}]...'.format(offer)
-        ))
-        self.assertTrue(actual_output.endswith('Done.'))
-        self.assertEqual(ConditionalOffer.objects.filter(**self.filter_condition).count(), 0)
-
-    def test_command_without_sample(self):
-        """Verify the command is only showing a message when no queryset is found."""
-        self.assertEqual(ConditionalOffer.objects.filter(**self.filter_condition).count(), 0)
-        output = self.call_command_and_return_output()
-        self.assertEqual('Nothing to do here.', output.getvalue().strip())
-        self.assertEqual(ConditionalOffer.objects.filter(**self.filter_condition).count(), 0)
-
-    def test_command_only_target_single_use_vouchers(self):
-        """Verify the command doesn't target multi-use vouchers."""
-        offer = factories.ConditionalOfferFactory(max_global_applications=1)
-        voucher = factories.VoucherFactory(usage=Voucher.MULTI_USE)
-        voucher.offers.add(offer)
-        output = self.call_command_and_return_output()
-        self.assertEqual('Nothing to do here.', output.getvalue().strip())
-        unaffected_offer = ConditionalOffer.objects.get(id=offer.id)
-        self.assertEqual(unaffected_offer.max_global_applications, 1)
-        self.assertEqual(unaffected_offer.vouchers.first().usage, Voucher.MULTI_USE)

ecommerce/invoice/management/commands/populate_invoice_orders.py

-import logging
-
-from django.core.management import BaseCommand
-from oscar.core.loading import get_model
-
-from ecommerce.core.models import BusinessClient
-from ecommerce.invoice.models import Invoice
-
-logger = logging.getLogger(__name__)
-Order = get_model('order', 'Order')
-
-
-class Command(BaseCommand):
-    """
-    Populate the order field for all invoices from the basket order,
-    and set the basket values to None. Creates a new business client object
-    from the basket owner username value and assigns it to the invoice if there
-    is not one assigned already.
-    """
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
-    logger.addHandler(ch)
-
-    def handle(self, *args, **options):
-        for invoice in Invoice.objects.all():
-            if invoice.basket:
-                try:
-                    order = Order.objects.get(basket=invoice.basket)
-                    invoice.order = order
-                    if not invoice.business_client:
-                        invoice.business_client, __ = BusinessClient.objects.get_or_create(
-                            name=invoice.basket.owner.username
-                        )
-                    invoice.basket = None
-                    invoice.save()
-                    logger.info('Order [%d] saved to invoice [%d].', order.id, invoice.id)
-                except Order.DoesNotExist:
-                    logger.info('Order for basket [%s] does not exist.', invoice.basket)

ecommerce/invoice/management/commands/squash_duplicate_invoices.py

-import logging
-
-from django.core.management import BaseCommand
-
-from ecommerce.extensions.catalogue.models import Product
-from ecommerce.invoice.models import Invoice
-
-logger = logging.getLogger(__name__)
-
-
-class Command(BaseCommand):
-    """
-    Squash duplicate invoices for coupon orders.
-    When we moved from re-using a coupon some of them had already more than one invoice,
-    and we are not having that! Monogamy rulez here, yerr damn hippies!
-    """
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
-    logger.addHandler(ch)
-
-    def handle(self, *args, **options):
-        for coupon in Product.objects.filter(product_class__name='Coupon'):
-            qs = Invoice.objects.filter(order__lines__product=coupon).order_by('created')
-            if qs.count() > 1:
-                qs.exclude(pk=qs.first().id).delete()
-                logger.info('Deleted douplicate invoices of coupon %s', coupon.id)

ecommerce/invoice/tests.py

-from django.core.management import call_command
-from oscar.core.loading import get_model
 from oscar.test import factories
 
-from ecommerce.core.models import BusinessClient
 from ecommerce.invoice.models import Invoice
 from ecommerce.tests.testcases import TestCase
 
-Order = get_model('order', 'Order')
-
 
 class InvoiceTests(TestCase):
     """Test to ensure Invoice objects are created correctly"""
@@ -30,103 +25,3 @@ class InvoiceTests(TestCase):
     def test_total(self):
         """Test to check invoice total"""
         self.assertEqual(self.basket.order.total_incl_tax, self.invoice.total)
-
-
-class PopulateInvoiceOrdersCommandTests(TestCase):
-    """Tests for the populate_invoice_orders command."""
-
-    def setUp(self):
-        super(PopulateInvoiceOrdersCommandTests, self).setUp()
-        self.order = factories.OrderFactory()
-        self.basket = factories.BasketFactory()
-        self.basket.owner = factories.UserFactory()
-        self.basket.save()
-
-    def test_order_populated(self):
-        """Verify the order field is populated and basket set to None."""
-        self.order.basket = self.basket
-        self.order.save()
-        invoice_before = Invoice.objects.create(basket=self.basket)
-        self.assertIsNone(invoice_before.order)
-
-        call_command('populate_invoice_orders')
-        invoice_after = Invoice.objects.first()
-        self.assertIsNone(invoice_after.basket)
-        self.assertEqual(invoice_after.order, self.order)
-
-    def test_non_existing_order(self):
-        """Verify the invoice is not altered if no order exists."""
-        self.assertIsNone(self.order.basket)
-        invoice_before = Invoice.objects.create(basket=self.basket)
-        invoice_before_no_basket = Invoice.objects.create()
-        self.assertIsNone(invoice_before.order)
-        self.assertIsNone(invoice_before_no_basket.order)
-
-        call_command('populate_invoice_orders')
-        invoices_after = Invoice.objects.all()
-        self.assertEqual(invoices_after.count(), 2)
-        self.assertIsNone(invoices_after.first().order)
-        self.assertIsNone(invoices_after.last().order)
-        self.assertEqual(invoices_after.get(id=invoice_before.id).basket, self.basket)
-
-    def test_client_changed(self):
-        """Verify the business client value is added if it doesn't exist."""
-        self.assertIsNotNone(self.basket.owner)
-        self.order.basket = self.basket
-        self.order.save()
-        invoice_before = Invoice.objects.create(basket=self.basket)
-        self.assertIsNone(invoice_before.business_client)
-        self.assertEqual(BusinessClient.objects.count(), 0)
-
-        call_command('populate_invoice_orders')
-        invoice_after = Invoice.objects.first()
-
-        self.assertEqual(BusinessClient.objects.count(), 1)
-        self.assertEqual(invoice_after.business_client, BusinessClient.objects.first())
-
-    def test_client_unchanged(self):
-        """Verify the business client value is unchanged if it exist."""
-        self.order.basket = self.basket
-        self.order.save()
-        business_client = BusinessClient.objects.create(name='Tester')
-        Invoice.objects.create(
-            basket=self.basket,
-            business_client=business_client
-        )
-
-        call_command('populate_invoice_orders')
-        invoice_after = Invoice.objects.first()
-        self.assertEqual(invoice_after.business_client, business_client)
-
-
-class SquashDuplicateInvoicesCommandTests(TestCase):
-    """Tests for the squash_duplicate_invoices command."""
-
-    def setUp(self):
-        super(SquashDuplicateInvoicesCommandTests, 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 assert_unique_invoice(self, product, invoice):
-        """Helper method for asserting there is only one invoice for given product."""
-        invoice_qs = Invoice.objects.filter(order__lines__product=product)
-        self.assertEqual(invoice_qs.count(), 1)
-        self.assertEqual(invoice_qs.first(), invoice)
-
-    def test_squashing_invoices(self):
-        """Verify after calling the command the duplicate invoices are squashed."""
-        Invoice.objects.create(order=self.order)
-        self.assertEqual(Invoice.objects.filter(order__lines__product=self.product).count(), 2)
-
-        call_command('squash_duplicate_invoices')
-        self.assert_unique_invoice(self.product, self.invoice)
-
-    def test_not_squashing_invoices(self):
-        """Verify the non-duplicate invoices are left the same."""
-        self.assertEqual(Invoice.objects.filter(order__lines__product=self.product).count(), 1)
-        call_command('squash_duplicate_invoices')
-        self.assert_unique_invoice(self.product, self.invoice)