Added Support for Processing Refunds

The Refund model includes approve and deny methods. The deny method updates the states of the Refund and RefundLine. The approve method issues payment credit and revokes fulfillment of the purchased items(s).

XCOM-338

ecommerce/extensions/api/serializers.py

 """Serializers for order and line item data."""
 # pylint: disable=abstract-method
 from oscar.core.loading import get_model
-
 from rest_framework import serializers
 
 from ecommerce.extensions.payment.constants import ISO_8601_FORMAT
@@ -11,6 +10,7 @@ Line = get_model('order', 'Line')
 Order = get_model('order', 'Order')
 Product = get_model('catalogue', 'Product')
 ProductAttributeValue = get_model('catalogue', 'ProductAttributeValue')
+Refund = get_model('refund', 'Refund')
 
 
 class BillingAddressSerializer(serializers.ModelSerializer):
@@ -74,3 +74,10 @@ class PaymentProcessorSerializer(serializers.Serializer):
     def to_representation(self, instance):
         """ Serialize instances as a string instead of a mapping object. """
         return instance.NAME
+
+
+class RefundSerializer(serializers.ModelSerializer):
+    """ Serializer for Refund objects. """
+
+    class Meta(object):
+        model = Refund

ecommerce/extensions/api/v2/tests/test_views.py

@@ -21,14 +21,14 @@ from rest_framework.throttling import UserRateThrottle
 
 from ecommerce.extensions.api import exceptions as api_exceptions
 from ecommerce.extensions.api.constants import APIConstants as AC
-from ecommerce.extensions.api.serializers import OrderSerializer
+from ecommerce.extensions.api.serializers import OrderSerializer, RefundSerializer
 from ecommerce.extensions.api.tests.test_authentication import AccessTokenMixin, OAUTH2_PROVIDER_URL
 from ecommerce.extensions.fulfillment.mixins import FulfillmentMixin
 from ecommerce.extensions.fulfillment.status import LINE, ORDER
 from ecommerce.extensions.payment import exceptions as payment_exceptions
 from ecommerce.extensions.payment.processors.cybersource import Cybersource
 from ecommerce.extensions.payment.tests.processors import DummyProcessor, AnotherDummyProcessor
-from ecommerce.extensions.refund.tests.factories import RefundLineFactory
+from ecommerce.extensions.refund.tests.factories import RefundLineFactory, RefundFactory
 from ecommerce.extensions.refund.tests.test_api import RefundTestMixin
 from ecommerce.tests.mixins import UserMixin, ThrottlingMixin, BasketCreationMixin, JwtMixin
 
@@ -373,7 +373,7 @@ class OrderFulfillViewTests(UserMixin, TestCase):
         return self.client.put(self.url)
 
     @ddt.data('delete', 'get', 'post')
-    def test_post_required(self, method):
+    def test_put_or_patch_required(self, method):
         """ Verify that the view only responds to PUT and PATCH operations. """
         response = getattr(self.client, method)(self.url)
         self.assertEqual(405, response.status_code)
@@ -624,3 +624,46 @@ class RefundCreateViewTests(RefundTestMixin, AccessTokenMixin, JwtMixin, UserMix
 
         self.assert_ok_response(response)
         self.assertEqual(Refund.objects.count(), 0)
+
+
+@ddt.ddt
+class RefundProcessViewTests(UserMixin, TestCase):
+    def setUp(self):
+        super(RefundProcessViewTests, self).setUp()
+
+        self.user = self.create_user(is_staff=True)
+        self.client.login(username=self.user.username, password=self.password)
+        self.refund = RefundFactory(user=self.user)
+
+    def put(self, action):
+        data = '{{"action": "{}"}}'.format(action)
+        path = reverse('api:v2:refunds:process', kwargs={'pk': self.refund.id})
+        return self.client.put(path, data, JSON_CONTENT_TYPE)
+
+    def test_staff_only(self):
+        """ The view should only be accessible to staff users. """
+        user = self.create_user(is_staff=False)
+        self.client.login(username=user.username, password=self.password)
+        response = self.put('approve')
+        self.assertEqual(response.status_code, 403)
+
+    def test_invalid_action(self):
+        """ If the action is neither approve nor deny, the view should return HTTP 400. """
+        response = self.put('reject')
+        self.assertEqual(response.status_code, 400)
+
+    @ddt.data('approve', 'deny')
+    def test_success(self, action):
+        """ If the action succeeds, the view should return HTTP 200 and the serialized Refund. """
+        with mock.patch('ecommerce.extensions.refund.models.Refund.{}'.format(action), mock.Mock(return_value=True)):
+            response = self.put(action)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.data, RefundSerializer(self.refund).data)
+
+    @ddt.data('approve', 'deny')
+    def test_failure(self, action):
+        """ If the action fails, the view should return HTTP 500 and the serialized Refund. """
+        with mock.patch('ecommerce.extensions.refund.models.Refund.{}'.format(action), mock.Mock(return_value=False)):
+            response = self.put(action)
+            self.assertEqual(response.status_code, 500)
+            self.assertEqual(response.data, RefundSerializer(self.refund).data)

ecommerce/extensions/api/v2/urls.py

@@ -3,7 +3,6 @@ from django.views.decorators.cache import cache_page
 
 from ecommerce.extensions.api.v2 import views
 
-
 ORDER_NUMBER_PATTERN = r'(?P<number>[-\w]+)'
 BASKET_ID_PATTERN = r'(?P<basket_id>[\w]+)'
 
@@ -40,6 +39,7 @@ PAYMENT_URLS = patterns(
 REFUND_URLS = patterns(
     '',
     url(r'^$', views.RefundCreateView.as_view(), name='create'),
+    url(r'^(?P<pk>[\d]+)/process/$', views.RefundProcessView.as_view(), name='process'),
 )
 
 urlpatterns = patterns(

ecommerce/extensions/api/v2/views.py

@@ -5,8 +5,9 @@ from django.conf import settings
 from django.contrib.auth import get_user_model
 from oscar.core.loading import get_model
 from rest_framework import status
+from rest_framework.exceptions import ParseError
 from rest_framework.generics import CreateAPIView, RetrieveAPIView, ListAPIView, UpdateAPIView
-from rest_framework.permissions import IsAuthenticated, DjangoModelPermissions
+from rest_framework.permissions import IsAuthenticated, DjangoModelPermissions, IsAdminUser
 from rest_framework.response import Response
 
 from ecommerce.extensions.api import data, exceptions as api_exceptions, serializers
@@ -20,10 +21,10 @@ from ecommerce.extensions.payment.helpers import (get_processor_class, get_defau
                                                   get_processor_class_by_name)
 from ecommerce.extensions.refund.api import find_orders_associated_with_course, create_refunds
 
-
 logger = logging.getLogger(__name__)
 
 Order = get_model('order', 'Order')
+Refund = get_model('refund', 'Refund')
 User = get_user_model()
 
 
@@ -413,7 +414,7 @@ class RefundCreateView(CreateAPIView):
             raise BadRequestException('No course_id specified.')
 
         # We should always have a username value as long as CanActForUser is in place.
-        if not username:    # pragma: no cover
+        if not username:  # pragma: no cover
             raise BadRequestException('No username specified.')
 
         try:
@@ -435,3 +436,39 @@ class RefundCreateView(CreateAPIView):
 
         # Return HTTP 200 if we did NOT create refunds.
         return Response([], status=status.HTTP_200_OK)
+
+
+class RefundProcessView(UpdateAPIView):
+    """
+    Process--approve or deny--refunds.
+
+    This view can be used to approve, or deny, a Refund. Under normal conditions, the view returns HTTP status 200
+    and a serialized Refund. In the event of an error, the view will still return a serialized Refund (to reflect any
+    changed statuses); however, HTTP status will be 500.
+
+    Only staff users are permitted to use this view.
+    """
+    permission_classes = (IsAuthenticated, IsAdminUser,)
+    queryset = Refund.objects.all()
+    serializer_class = serializers.RefundSerializer
+
+    def update(self, request, *args, **kwargs):
+        APPROVE = 'approve'
+        DENY = 'deny'
+
+        action = request.data.get('action', '').lower()
+
+        if action not in (APPROVE, DENY):
+            raise ParseError('The action [{}] is not valid.'.format(action))
+
+        refund = self.get_object()
+        result = False
+
+        if action == APPROVE:
+            result = refund.approve()
+        elif action == DENY:
+            result = refund.deny()
+
+        http_status = status.HTTP_200_OK if result else status.HTTP_500_INTERNAL_SERVER_ERROR
+        serializer = self.get_serializer(refund)
+        return Response(serializer.data, status=http_status)

ecommerce/extensions/catalogue/tests/mixins.py

+from oscar.core.loading import get_model
+from oscar.test import factories
+
+ProductClass = get_model('catalogue', 'ProductClass')
+ProductAttribute = get_model('catalogue', 'ProductAttribute')
+
+
+class CourseCatalogTestMixin(object):
+    @property
+    def seat_product_class(self):
+        defaults = {'requires_shipping': False, 'track_stock': False, 'name': 'Seat'}
+        product_class, created = ProductClass.objects.get_or_create(slug='seat', defaults=defaults)
+
+        if created:
+            factories.ProductAttributeFactory(code='certificate_type', product_class=product_class, type='text')
+            factories.ProductAttributeFactory(code='course_key', product_class=product_class, type='text')
+
+        return product_class
+
+    def create_course_seats(self, course_id, certificate_types):
+        title = 'Seat in {}'.format(course_id)
+        parent_product = factories.ProductFactory(structure='parent', title=title,
+                                                  product_class=self.seat_product_class)
+
+        seats = {}
+        for certificate_type in certificate_types:
+            seat_title = '{title} with {type} certificate'.format(title=title, type=certificate_type)
+            seat = factories.ProductFactory(structure='child', title=seat_title, product_class=None,
+                                            parent=parent_product)
+
+            seat.attr.certificate_type = certificate_type
+            seat.attr.course_key = course_id
+            seat.save()
+
+            factories.StockRecordFactory(product=seat)
+
+            seats[certificate_type] = seat
+
+        return seats

ecommerce/extensions/dashboard/refunds/tests/test_acceptance.py

@@ -10,14 +10,18 @@ from selenium.webdriver.firefox.webdriver import WebDriver
 from selenium.webdriver.support.wait import WebDriverWait
 
 from ecommerce.extensions.refund.status import REFUND
-from ecommerce.extensions.refund.tests.factories import RefundFactory
-
+from ecommerce.extensions.refund.tests.mixins import RefundTestMixin
 
 Refund = get_model('refund', 'Refund')
 
+ALL_REFUND_STATUSES = (
+    REFUND.OPEN, REFUND.PAYMENT_REFUND_ERROR, REFUND.PAYMENT_REFUNDED, REFUND.REVOCATION_ERROR, REFUND.COMPLETE,
+    REFUND.DENIED
+)
+
 
 @ddt.ddt
-class RefundAcceptanceTestMixin(object):
+class RefundAcceptanceTestMixin(RefundTestMixin):
     @classmethod
     def setUpClass(cls):
         cls.selenium = WebDriver()
@@ -31,7 +35,8 @@ class RefundAcceptanceTestMixin(object):
     def setUp(self):
         super(RefundAcceptanceTestMixin, self).setUp()
 
-        self.refund = RefundFactory()
+        self.refund = self.create_refund()
+
         self.approve_button_selector = '[data-refund-id="{}"] [data-decision="approve"]'.format(self.refund.id)
         self.deny_button_selector = '[data-refund-id="{}"] [data-decision="deny"]'.format(self.refund.id)
 
@@ -125,7 +130,7 @@ class RefundAcceptanceTestMixin(object):
         # Verify that the refund's status is updated.
         selector = 'tr[data-refund-id="{}"] .refund-status'.format(refund_id)
         status = self.selenium.find_element_by_css_selector(selector)
-        self.assertEqual(REFUND.ERROR, status.text)
+        self.assertEqual('Error', status.text)
 
         # Verify that an alert is displayed.
         self.assert_alert_displayed(
@@ -134,7 +139,7 @@ class RefundAcceptanceTestMixin(object):
             'Please try again, or contact the E-Commerce Development Team.'.format(refund_id=refund_id)
         )
 
-    @ddt.data(REFUND.OPEN, REFUND.DENIED, REFUND.ERROR, REFUND.COMPLETE)
+    @ddt.data(*ALL_REFUND_STATUSES)
     def test_button_configurations(self, status):
         """
         Verify correct button configurations for different refund statuses.
@@ -165,6 +170,7 @@ class RefundAcceptanceTestMixin(object):
 
 class RefundListViewTests(RefundAcceptanceTestMixin, LiveServerTestCase):
     """Acceptance tests of the refund list view."""
+
     def setUp(self):
         super(RefundListViewTests, self).setUp()
         self.path = reverse('dashboard:refunds:list')
@@ -172,6 +178,7 @@ class RefundListViewTests(RefundAcceptanceTestMixin, LiveServerTestCase):
 
 class RefundDetailViewTests(RefundAcceptanceTestMixin, LiveServerTestCase):
     """Acceptance tests of the refund detail view."""
+
     def setUp(self):
         super(RefundDetailViewTests, self).setUp()
         self.path = reverse('dashboard:refunds:detail', args=[self.refund.id])

ecommerce/extensions/fulfillment/api.py

@@ -12,7 +12,7 @@ from django.utils import importlib
 
 from ecommerce.extensions.fulfillment import exceptions
 from ecommerce.extensions.fulfillment.status import ORDER, LINE
-
+from ecommerce.extensions.refund.status import REFUND_LINE
 
 logger = logging.getLogger(__name__)
 
@@ -40,7 +40,6 @@ def fulfill_order(order, lines):
         error_msg = "Order has a current status of [{status}] which cannot be fulfilled.".format(status=order.status)
         logger.error(error_msg)
         raise exceptions.IncorrectOrderStatusError(error_msg)
-    modules = getattr(settings, 'FULFILLMENT_MODULES', {})
 
     # Construct a dict of lines by their product type.
     line_items = list(lines.all())
@@ -50,22 +49,21 @@ def fulfill_order(order, lines):
         # any of the lines in the order. Fulfill line items in the order they are designated by the configuration.
         # Remaining line items should be marked with a fulfillment error since we have no configuration that
         # allows them to be fulfilled.
-        for cls_path in modules:
-            try:
-                module_path, _, name = cls_path.rpartition('.')
-                module = getattr(importlib.import_module(module_path), name)
-                supported_lines = module().get_supported_lines(order, line_items)
-                line_items = list(set(line_items) - set(supported_lines))
-                module().fulfill_product(order, supported_lines)
-            except (ImportError, ValueError, AttributeError):
-                logger.exception("Could not load module at [%s]", cls_path)
+        for module_class in get_fulfillment_modules():
+            module = module_class()
+            supported_lines = module.get_supported_lines(line_items)
+            line_items = list(set(line_items) - set(supported_lines))
+            module.fulfill_product(order, supported_lines)
 
         # Check to see if any line items in the order have not been accounted for by a FulfillmentModule
         # Any product does not line up with a module, we have to mark a fulfillment error.
         for line in line_items:
-            product_type = line.product.product_class.name
-            logger.error("Product Type [%s] in order does not have an associated Fulfillment Module", product_type)
+            product_type = line.product.get_product_class().name
+            logger.error("Product Type [%s] does not have an associated Fulfillment Module. It cannot be fulfilled.",
+                         product_type)
             line.set_status(LINE.FULFILLMENT_CONFIGURATION_ERROR)
+    except Exception:   # pylint: disable=broad-except
+        logger.exception('An error occurred while fulfilling order [%s].', order.number)
     finally:
         # Check if all lines are successful, or there were errors, and set the status of the Order.
         order_status = ORDER.COMPLETE
@@ -77,3 +75,54 @@ def fulfill_order(order, lines):
         order.set_status(order_status)
         logger.info("Finished fulfilling order [%s] with status [%s]", order.number, order.status)
         return order  # pylint: disable=lost-exception
+
+
+def get_fulfillment_modules():
+    """ Retrieves all fulfillment modules declared in settings. """
+    module_paths = getattr(settings, 'FULFILLMENT_MODULES', [])
+    modules = []
+
+    for cls_path in module_paths:
+        try:
+            module_path, _, name = cls_path.rpartition('.')
+            module = getattr(importlib.import_module(module_path), name)
+            modules.append(module)
+        except (ImportError, ValueError, AttributeError):
+            logger.exception("Could not load module at [%s]", cls_path)
+
+    return modules
+
+
+def get_fulfillment_modules_for_line(line):
+    """
+    Returns a list of fulfillment modules that can fulfill the given Line.
+
+    Arguments
+        line (Line): Line to be considered for fulfillment.
+    """
+    return [module for module in get_fulfillment_modules() if module().supports_line(line)]
+
+
+def revoke_fulfillment_for_refund(refund):
+    """
+    Revokes fulfillment for all lines in a refund.
+
+    Returns
+        Boolean: True, if revocation of all lines succeeded; otherwise, False.
+    """
+    succeeded = True
+
+    # TODO (CCB): As our list of product types and fulfillment modules grows, this may become slow,
+    # and should be updated. Runtime is O(n^2).
+    for refund_line in refund.lines.all():
+        order_line = refund_line.order_line
+        modules = get_fulfillment_modules_for_line(order_line)
+
+        for module in modules:
+            if module().revoke_line(order_line):
+                refund_line.set_status(REFUND_LINE.COMPLETE)
+            else:
+                succeeded = False
+                refund_line.set_status(REFUND_LINE.REVOCATION_ERROR)
+
+    return succeeded

ecommerce/extensions/fulfillment/modules.py

@@ -8,14 +8,12 @@ import json
 import logging
 
 from django.conf import settings
-from oscar.apps.catalogue.models import ProductAttributeValue
 from rest_framework import status
 import requests
 from requests.exceptions import ConnectionError, Timeout
 
 from ecommerce.extensions.fulfillment.status import LINE
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -28,22 +26,30 @@ class BaseFulfillmentModule(object):  # pragma: no cover
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
-    def get_supported_lines(self, order, lines):
-        """ Return a list of supported lines in the order
+    def supports_line(self, line):
+        """
+        Returns True if the given Line can be fulfilled/revoked by this module.
+
+        Args:
+            line (Line): Line to be considered.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_supported_lines(self, lines):
+        """ Return a list of supported lines
 
         Each Fulfillment Module is capable of fulfillment certain products. This function allows a preliminary
         check of which lines could be supported by this Fulfillment Module.
 
-         By evaluating the order and the lines, this will return a list of all the lines in the order that
+         By evaluating the lines, this will return a list of all the lines in the order that
          can be fulfilled by this module.
 
         Args:
-            order (Order): The Order associated with the lines to be fulfilled
             lines (List of Lines): Order Lines, associated with purchased products in an Order.
 
         Returns:
             A supported list of lines, unmodified.
-
         """
         raise NotImplementedError("Line support method not implemented!")
 
@@ -66,19 +72,14 @@ class BaseFulfillmentModule(object):  # pragma: no cover
         raise NotImplementedError("Fulfillment method not implemented!")
 
     @abc.abstractmethod
-    def revoke_product(self, order, lines):
-        """ Revokes the specified lines in the order.
-
-        Iterates over the given lines and revokes the associated products, if possible.  Reports success if the product
-        can be revoked, but may fail if the module cannot support revoking or process of revoking the product fails
-        due to underlying services.
+    def revoke_line(self, line):
+        """ Revokes the specified line.
 
         Args:
-            order (Order): The Order associated with the lines to be revoked.
-            lines (List of Lines): Order Lines, associated with purchased products in an Order.
+            line (Line): Order Line to be revoked.
 
         Returns:
-            The original set of lines, with new statuses set based on the success or failure of revoking the products.
+            True, if the product is revoked; otherwise, False.
         """
         raise NotImplementedError("Revoke method not implemented!")
 
@@ -87,29 +88,36 @@ class EnrollmentFulfillmentModule(BaseFulfillmentModule):
     """ Fulfillment Module for enrolling students after a product purchase.
 
     Allows the enrollment of a student via purchase of a 'seat'.
-
     """
 
-    def get_supported_lines(self, order, lines):
+    def _post_to_enrollment_api(self, data):
+        enrollment_api_url = settings.ENROLLMENT_API_URL
+        timeout = settings.ENROLLMENT_FULFILLMENT_TIMEOUT
+
+        headers = {
+            'Content-Type': 'application/json',
+            'X-Edx-Api-Key': settings.EDX_API_KEY
+        }
+
+        return requests.post(enrollment_api_url, data=json.dumps(data), headers=headers, timeout=timeout)
+
+    def supports_line(self, line):
+        return line.product.get_product_class().name == 'Seat'
+
+    def get_supported_lines(self, lines):
         """ Return a list of lines that can be fulfilled through enrollment.
 
-        Check each line in the order to see if it is a "Seat". Seats are fulfilled by enrolling students
+        Checks each line to determine if it is a "Seat". Seats are fulfilled by enrolling students
         in a course, which is the sole functionality of this module. Any Seat product will be returned as
-        a supported line in the order.
+        a supported line.
 
         Args:
-            order (Order): The Order associated with the lines to be fulfilled
             lines (List of Lines): Order Lines, associated with purchased products in an Order.
 
         Returns:
             A supported list of unmodified lines associated with "Seat" products.
-
         """
-        supported_lines = []
-        for line in lines:
-            if line.product.get_product_class().name == 'Seat':
-                supported_lines.append(line)
-        return supported_lines
+        return [line for line in lines if self.supports_line(line)]
 
     def fulfill_product(self, order, lines):
         """ Fulfills the purchase of a 'seat' by enrolling the associated student.
@@ -132,18 +140,20 @@ class EnrollmentFulfillmentModule(BaseFulfillmentModule):
 
         enrollment_api_url = getattr(settings, 'ENROLLMENT_API_URL', None)
         api_key = getattr(settings, 'EDX_API_KEY', None)
-        if not enrollment_api_url or not api_key:
+        if not (enrollment_api_url and api_key):
             logger.error(
-                "ENROLLMENT_API_URL and EDX_API_KEY must be set to use the EnrollmentFulfillmentModule"
+                'ENROLLMENT_API_URL and EDX_API_KEY must be set to use the EnrollmentFulfillmentModule'
             )
             for line in lines:
                 line.set_status(LINE.FULFILLMENT_CONFIGURATION_ERROR)
 
+            return order, lines
+
         for line in lines:
             try:
-                certificate_type = line.product.attribute_values.get(attribute__name="certificate_type").value
-                course_key = line.product.attribute_values.get(attribute__name="course_key").value
-            except ProductAttributeValue.DoesNotExist:
+                certificate_type = line.product.attr.certificate_type
+                course_key = line.product.attr.course_key
+            except AttributeError:
                 logger.error("Supported Seat Product does not have required attributes, [certificate_type, course_key]")
                 line.set_status(LINE.FULFILLMENT_CONFIGURATION_ERROR)
                 continue
@@ -156,18 +166,8 @@ class EnrollmentFulfillmentModule(BaseFulfillmentModule):
                 }
             }
 
-            headers = {
-                'Content-Type': 'application/json',
-                'X-Edx-Api-Key': api_key,
-            }
-
             try:
-                response = requests.post(
-                    enrollment_api_url,
-                    data=json.dumps(data),
-                    headers=headers,
-                    timeout=getattr(settings, 'ENROLLMENT_FULFILLMENT_TIMEOUT', 5)
-                )
+                response = self._post_to_enrollment_api(data)
 
                 if response.status_code == status.HTTP_200_OK:
                     logger.info("Success fulfilling line [%d] of order [%s].", line.id, order.number)
@@ -197,5 +197,28 @@ class EnrollmentFulfillmentModule(BaseFulfillmentModule):
         logger.info("Finished fulfilling 'Seat' product types for order [%s]", order.number)
         return order, lines
 
-    def revoke_product(self, order, lines):
-        raise NotImplementedError
+    def revoke_line(self, line):
+        try:
+            logger.info('Attempting to revoke fulfillment of Line [%d]...', line.id)
+
+            data = {
+                'user': line.order.user.username,
+                'is_active': False,
+                'course_details': {
+                    'course_id': line.product.attr.course_key
+                }
+            }
+
+            response = self._post_to_enrollment_api(data)
+
+            if response.status_code == status.HTTP_200_OK:
+                logger.info('Successfully revoked line [%d].', line.id)
+                return True
+            else:
+                data = response.json()
+                detail = data.get('message', '(No details provided.)')
+                logger.error('Failed to revoke fulfillment of Line [%d]: %s', line.id, detail)
+        except Exception:  # pylint: disable=broad-except
+            logger.exception('Failed to revoke fulfillment of Line [%d].', line.id)
+
+        return False

ecommerce/extensions/fulfillment/tests/modules.py

@@ -2,21 +2,27 @@ from ecommerce.extensions.fulfillment.modules import BaseFulfillmentModule
 from ecommerce.extensions.fulfillment.status import LINE
 
 
-class MockFulFillmentModule(BaseFulfillmentModule):
-    def get_supported_lines(self, order, lines):
+class MockFulfillmentModule(BaseFulfillmentModule):
+    def supports_line(self, line):
+        pass
+
+    def get_supported_lines(self, lines):
         pass
 
     def fulfill_product(self, order, lines):
         pass
 
-    def revoke_product(self, order, lines):
+    def revoke_line(self, line):
         pass
 
 
-class FakeFulfillmentModule(MockFulFillmentModule):
+class FakeFulfillmentModule(MockFulfillmentModule):
     """Fake Fulfillment Module used to test the API without specific implementations."""
 
-    def get_supported_lines(self, order, lines):
+    def supports_line(self, line):
+        return True
+
+    def get_supported_lines(self, lines):
         """Returns a list of lines this Fake module supposedly supports."""
         return lines
 
@@ -25,10 +31,33 @@ class FakeFulfillmentModule(MockFulFillmentModule):
         for line in lines:
             line.set_status(LINE.COMPLETE)
 
+    def revoke_line(self, line):
+        """ Always revoke the product. """
+        return True
 
-class FulfillmentNothingModule(MockFulFillmentModule):
+
+class FulfillmentNothingModule(MockFulfillmentModule):
     """Fake Fulfillment Module that refuses to fulfill anything."""
 
-    def get_supported_lines(self, order, lines):
+    def supports_line(self, line):
+        return False
+
+    def get_supported_lines(self, lines):
         """Returns an empty list, because this module supports nothing."""
         return []
+
+
+class RevocationFailureModule(MockFulfillmentModule):
+    """ This module supports all Lines, but fulfills none. Use it to test revocation failures. """
+
+    def get_supported_lines(self, lines):
+        """ Returns the lines passed to indicate the module supports fulfilling all of them."""
+        return lines
+
+    def supports_line(self, line):
+        """ Returns True since the module supports fulfillment of all Lines."""
+        return True
+
+    def revoke_line(self, line):
+        """ Returns False to simulate a revocation failure."""
+        return False

ecommerce/extensions/fulfillment/tests/test_api.py

@@ -3,46 +3,99 @@ import ddt
 from django.test import TestCase
 from django.test.utils import override_settings
 from nose.tools import raises
+from testfixtures import LogCapture
 
 from ecommerce.extensions.fulfillment import api, exceptions
+from ecommerce.extensions.fulfillment.api import get_fulfillment_modules, get_fulfillment_modules_for_line, \
+    revoke_fulfillment_for_refund
 from ecommerce.extensions.fulfillment.status import ORDER, LINE
 from ecommerce.extensions.fulfillment.tests.mixins import FulfillmentTestMixin
+from ecommerce.extensions.fulfillment.tests.modules import FakeFulfillmentModule
+from ecommerce.extensions.refund.status import REFUND, REFUND_LINE
+from ecommerce.extensions.refund.tests.factories import RefundFactory
 
 
 @ddt.ddt
-class FulfillmentTest(FulfillmentTestMixin, TestCase):
-    """
-    Test course seat fulfillment.
-    """
+class FulfillmentApiTests(FulfillmentTestMixin, TestCase):
+    """ Tests for the fulfillment.api module. """
 
     def setUp(self):
-        super(FulfillmentTest, self).setUp()
+        super(FulfillmentApiTests, self).setUp()
         self.order = self.generate_open_order()
 
     @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FakeFulfillmentModule', ])
-    def test_successful_fulfillment(self):
+    def test_fulfill_order_successful_fulfillment(self):
         """ Test a successful fulfillment of an order. """
         api.fulfill_order(self.order, self.order.lines)
         self.assert_order_fulfilled(self.order)
 
     @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FakeFulfillmentModule', ])
     @raises(exceptions.IncorrectOrderStatusError)
-    def test_bad_fulfillment_state(self):
+    def test_fulfill_order_bad_fulfillment_state(self):
         """Test a basic fulfillment of a Course Seat."""
         # Set the order to Refunded, which cannot be fulfilled.
         self.order.set_status(ORDER.COMPLETE)
         api.fulfill_order(self.order, self.order.lines)
 
     @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FulfillNothingModule', ])
-    def test_unknown_product_type(self):
+    def test_fulfill_order_unknown_product_type(self):
         """Test an incorrect Fulfillment Module."""
         api.fulfill_order(self.order, self.order.lines)
         self.assertEquals(ORDER.FULFILLMENT_ERROR, self.order.status)
         self.assertEquals(LINE.FULFILLMENT_CONFIGURATION_ERROR, self.order.lines.all()[0].status)
 
     @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.NotARealModule', ])
-    def test_incorrect_module(self):
+    def test_fulfill_order_incorrect_module(self):
         """Test an incorrect Fulfillment Module."""
         api.fulfill_order(self.order, self.order.lines)
         self.assertEquals(ORDER.FULFILLMENT_ERROR, self.order.status)
         self.assertEquals(LINE.FULFILLMENT_CONFIGURATION_ERROR, self.order.lines.all()[0].status)
+
+    @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FakeFulfillmentModule',
+                                            'ecommerce.extensions.fulfillment.tests.modules.NotARealModule'])
+    def test_get_fulfillment_modules(self):
+        """
+        Verify the function retrieves the modules specified in settings.
+        An error should be logged for modules that cannot be logged.
+        """
+        logger_name = 'ecommerce.extensions.fulfillment.api'
+
+        with LogCapture(logger_name) as l:
+            actual = get_fulfillment_modules()
+
+            # Only FakeFulfillmentModule should be loaded since it is the only real class.
+            self.assertEqual(actual, [FakeFulfillmentModule])
+
+            # An error should be logged for NotARealModule since it cannot be loaded.
+            l.check((logger_name, 'ERROR',
+                     'Could not load module at [ecommerce.extensions.fulfillment.tests.modules.NotARealModule]'))
+
+    @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FakeFulfillmentModule',
+                                            'ecommerce.extensions.fulfillment.tests.modules.FulfillNothingModule'])
+    def test_get_fulfillment_modules_for_line(self):
+        """
+        Verify the function returns an array of fulfillment modules that can fulfill a specific line.
+        """
+        line = self.order.lines.first()
+        actual = get_fulfillment_modules_for_line(line)
+        self.assertEqual(actual, [FakeFulfillmentModule])
+
+    @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.FakeFulfillmentModule'])
+    def test_revoke_fulfillment_for_refund(self):
+        """
+        Verify the function revokes fulfillment for all lines in a refund.
+        """
+        refund = RefundFactory(status=REFUND.PAYMENT_REFUNDED)
+        self.assertTrue(revoke_fulfillment_for_refund(refund))
+        self.assertEqual(refund.status, REFUND.PAYMENT_REFUNDED)
+        self.assertEqual(set([line.status for line in refund.lines.all()]), {REFUND_LINE.COMPLETE})
+
+    @override_settings(FULFILLMENT_MODULES=['ecommerce.extensions.fulfillment.tests.modules.RevocationFailureModule'])
+    def test_revoke_fulfillment_for_refund_revocation_error(self):
+        """
+        Verify the function sets the status of RefundLines and the Refund to "Revocation Error" if revocation fails.
+        """
+        refund = RefundFactory(status=REFUND.PAYMENT_REFUNDED)
+        self.assertFalse(revoke_fulfillment_for_refund(refund))
+        self.assertEqual(refund.status, REFUND.PAYMENT_REFUNDED)
+        self.assertEqual(set([line.status for line in refund.lines.all()]), {REFUND_LINE.REVOCATION_ERROR})

ecommerce/extensions/fulfillment/tests/test_modules.py

 """Tests of the Fulfillment API's fulfillment modules."""
+import json
+
 import ddt
+from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.test import TestCase, override_settings
-from oscar.test.newfactories import UserFactory, BasketFactory
+import httpretty
 import mock
-from nose.tools import raises
+from oscar.core.loading import get_model
 from oscar.test import factories
-from requests import Response
+from oscar.test.newfactories import UserFactory, BasketFactory
 from requests.exceptions import ConnectionError, Timeout
-from rest_framework import status
+from testfixtures import LogCapture
+from ecommerce.extensions.catalogue.tests.mixins import CourseCatalogTestMixin
 
 from ecommerce.extensions.fulfillment.modules import EnrollmentFulfillmentModule
 from ecommerce.extensions.fulfillment.status import LINE
 from ecommerce.extensions.fulfillment.tests.mixins import FulfillmentTestMixin
 
-
+JSON = 'application/json'
+ProductAttribute = get_model("catalogue", "ProductAttribute")
 User = get_user_model()
 
 
 @ddt.ddt
 @override_settings(EDX_API_KEY='foo')
-class EnrollmentFulfillmentModuleTests(FulfillmentTestMixin, TestCase):
+class EnrollmentFulfillmentModuleTests(CourseCatalogTestMixin, FulfillmentTestMixin, TestCase):
     """Test course seat fulfillment."""
+    course_id = 'edX/DemoX/Demo_Course'
 
     def setUp(self):
         user = UserFactory()
-        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=None,
-            parent=self.course
-        )
+
+        certificate_type = 'honor'
+        seats = self.create_course_seats(self.course_id, (certificate_type,))
+        self.seat = seats[certificate_type]
+
         for stock_record in self.seat.stockrecords.all():
             stock_record.price_currency = 'USD'
             stock_record.save()
@@ -49,17 +46,13 @@ class EnrollmentFulfillmentModuleTests(FulfillmentTestMixin, TestCase):
 
     def test_enrollment_module_support(self):
         """Test that we get the correct values back for supported product lines."""
-        supported_lines = EnrollmentFulfillmentModule().get_supported_lines(self.order, list(self.order.lines.all()))
+        supported_lines = EnrollmentFulfillmentModule().get_supported_lines(list(self.order.lines.all()))
         self.assertEqual(1, len(supported_lines))
 
-    @mock.patch('requests.post')
-    def test_enrollment_module_fulfill(self, mock_post_request):
+    @httpretty.activate
+    def test_enrollment_module_fulfill(self):
         """Happy path test to ensure we can properly fulfill enrollments."""
-        fake_enrollment_api_response = Response()
-        fake_enrollment_api_response.status_code = status.HTTP_200_OK
-        mock_post_request.return_value = fake_enrollment_api_response
-
-        self._create_attributes()
+        httpretty.register_uri(httpretty.POST, settings.ENROLLMENT_API_URL, status=200, body='{}', content_type=JSON)
 
         # Attempt to enroll.
         EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
@@ -73,63 +66,81 @@ class EnrollmentFulfillmentModuleTests(FulfillmentTestMixin, TestCase):
 
     def test_enrollment_module_fulfill_bad_attributes(self):
         """Test that use of the Fulfillment Module fails when the product does not have attributes."""
-        # Attempt to enroll without creating the product attributes.
+        ProductAttribute.objects.get(code='course_key').delete()
         EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
         self.assertEqual(LINE.FULFILLMENT_CONFIGURATION_ERROR, self.order.lines.all()[0].status)
 
     @mock.patch('requests.post', mock.Mock(side_effect=ConnectionError))
     def test_enrollment_module_network_error(self):
         """Test that lines receive a network error status if a fulfillment request experiences a network error."""
-        self._create_attributes()
         EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
         self.assertEqual(LINE.FULFILLMENT_NETWORK_ERROR, self.order.lines.all()[0].status)
 
     @mock.patch('requests.post', mock.Mock(side_effect=Timeout))
     def test_enrollment_module_request_timeout(self):
         """Test that lines receive a timeout error status if a fulfillment request times out."""
-        self._create_attributes()
         EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
         self.assertEqual(LINE.FULFILLMENT_TIMEOUT_ERROR, self.order.lines.all()[0].status)
 
+    @httpretty.activate
     @ddt.data(None, '{"message": "Oops!"}')
-    def test_enrollment_module_server_error(self, response_content):
+    def test_enrollment_module_server_error(self, body):
         """Test that lines receive a server-side error status if a server-side error occurs during fulfillment."""
         # NOTE: We are testing for cases where the response does and does NOT have data. The module should be able
         # to handle both cases.
-        fake_error_response = Response()
-        fake_error_response._content = response_content  # pylint: disable=protected-access
-        fake_error_response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
-
-        with mock.patch('requests.post', return_value=fake_error_response):
-            self._create_attributes()
-
-            # Attempt to enroll
-            EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
-            self.assertEqual(LINE.FULFILLMENT_SERVER_ERROR, self.order.lines.all()[0].status)
-
-    @raises(NotImplementedError)
-    def test_enrollment_module_revoke(self):
-        """Test that use of this method due to "not implemented" error."""
-        EnrollmentFulfillmentModule().revoke_product(self.order, list(self.order.lines.all()))
-
-    def _create_attributes(self):
-        """Create enrollment attributes and values for the Honor Seat in DemoX Course."""
-        certificate_type = factories.ProductAttributeFactory(
-            name='certificate_type', product_class=self.product_class, type="text"
-        )
-        certificate_type.save()
-
-        course_key = factories.ProductAttributeFactory(
-            name='course_key', product_class=self.product_class, type="text"
-        )
-        course_key.save()
-
-        certificate_value = factories.ProductAttributeValueFactory(
-            attribute=certificate_type, product=self.seat, value_text='honor'
-        )
-        certificate_value.save()
-
-        key_value = factories.ProductAttributeValueFactory(
-            attribute=course_key, product=self.seat, value_text='edX/DemoX/Demo_Course'
-        )
-        key_value.save()
+        httpretty.register_uri(httpretty.POST, settings.ENROLLMENT_API_URL, status=500, body=body, content_type=JSON)
+        EnrollmentFulfillmentModule().fulfill_product(self.order, list(self.order.lines.all()))
+        self.assertEqual(LINE.FULFILLMENT_SERVER_ERROR, self.order.lines.all()[0].status)
+
+    @httpretty.activate
+    def test_revoke_product(self):
+        """ The method should call the Enrollment API to un-enroll the student, and return True. """
+        httpretty.register_uri(httpretty.POST, settings.ENROLLMENT_API_URL, status=200, body='{}', content_type=JSON)
+        line = self.order.lines.first()
+        self.assertTrue(EnrollmentFulfillmentModule().revoke_line(line))
+
+        actual = json.loads(httpretty.last_request().body)
+        expected = {
+            'user': self.order.user.username,
+            'is_active': False,
+            'course_details': {
+                'course_id': self.course_id
+            }
+        }
+        self.assertEqual(actual, expected)
+
+    @httpretty.activate
+    def test_revoke_product_api_error(self):
+        """ If the Enrollment API responds with a non-200 status, the method should log an error and return False. """
+        message = 'Meh.'
+        body = '{{"message": "{}"}}'.format(message)
+        httpretty.register_uri(httpretty.POST, settings.ENROLLMENT_API_URL, status=500, body=body, content_type=JSON)
+
+        line = self.order.lines.first()
+        logger_name = 'ecommerce.extensions.fulfillment.modules'
+        with LogCapture(logger_name) as l:
+            self.assertFalse(EnrollmentFulfillmentModule().revoke_line(line))
+            l.check(
+                (logger_name, 'INFO', 'Attempting to revoke fulfillment of Line [{}]...'.format(line.id)),
+                (logger_name, 'ERROR', 'Failed to revoke fulfillment of Line [%d]: %s' % (line.id, message))
+            )
+
+    @httpretty.activate
+    def test_revoke_product_unknown_exception(self):
+        """
+        If an exception is raised while contacting the Enrollment API, the method should log an error and return False.
+        """
+
+        def request_callback(_method, _uri, _headers):
+            raise Timeout
+
+        httpretty.register_uri(httpretty.POST, settings.ENROLLMENT_API_URL, body=request_callback)
+        line = self.order.lines.first()
+        logger_name = 'ecommerce.extensions.fulfillment.modules'
+
+        with LogCapture(logger_name) as l:
+            self.assertFalse(EnrollmentFulfillmentModule().revoke_line(line))
+            l.check(
+                (logger_name, 'INFO', 'Attempting to revoke fulfillment of Line [{}]...'.format(line.id)),
+                (logger_name, 'ERROR', 'Failed to revoke fulfillment of Line [{}].'.format(line.id))
+            )

ecommerce/extensions/payment/processors/__init__.py

@@ -75,3 +75,15 @@ class BasePaymentProcessor(object):  # pragma: no cover
         """
         return PaymentProcessorResponse.objects.create(processor_name=self.NAME, transaction_id=transaction_id,
                                                        response=response, basket=basket)
+
+    @abc.abstractmethod
+    def issue_credit(self, source, amount, currency):
+        """
+        Issue a credit for the specified transaction.
+
+        Arguments:
+            source (Source): Payment Source used for the original debit/purchase.
+            amount (Decimal): amount to be credited/refunded
+            currency (string): currency of the amount to be credited
+        """
+        raise NotImplementedError

ecommerce/extensions/payment/processors/cybersource.py

+""" CyberSource payment processing. """
+
 import datetime
 from decimal import Decimal
 import logging
@@ -6,14 +8,14 @@ import uuid
 from django.conf import settings
 from oscar.apps.payment.exceptions import UserCancelled, GatewayError, TransactionDeclined
 from oscar.core.loading import get_model
+from suds.client import Client
+from suds.sudsobject import asdict
+from suds.wsse import Security, UsernameToken
 
 from ecommerce.extensions.order.constants import PaymentEventTypeName
 from ecommerce.extensions.payment.constants import ISO_8601_FORMAT, CYBERSOURCE_CARD_TYPE_MAP
-from ecommerce.extensions.payment.exceptions import (
-    InvalidSignatureError,
-    InvalidCybersourceDecision,
-    PartialAuthorizationError,
-)
+from ecommerce.extensions.payment.exceptions import (InvalidSignatureError, InvalidCybersourceDecision,
+                                                     PartialAuthorizationError)
 from ecommerce.extensions.payment.helpers import sign
 from ecommerce.extensions.payment.processors import BasePaymentProcessor
 
@@ -34,6 +36,7 @@ class Cybersource(BasePaymentProcessor):
     For reference, see
     http://apps.cybersource.com/library/documentation/dev_guides/Secure_Acceptance_WM/Secure_Acceptance_WM.pdf.
     """
+
     NAME = u'cybersource'
 
     def __init__(self):
@@ -45,6 +48,9 @@ class Cybersource(BasePaymentProcessor):
             AttributeError: If LANGUAGE_CODE setting is not set.
         """
         configuration = self.configuration
+        self.soap_api_url = configuration['soap_api_url']
+        self.merchant_id = configuration['merchant_id']
+        self.transaction_key = configuration['transaction_key']
         self.profile_id = configuration['profile_id']
         self.access_key = configuration['access_key']
         self.secret_key = configuration['secret_key']
@@ -112,8 +118,13 @@ class Cybersource(BasePaymentProcessor):
         except ProductClass.DoesNotExist:
             # this occurs in test configurations where the seat product class is not in use
             return None
-        line = basket.lines.filter(product__product_class=seat_class).first()
-        return line.product if line else None
+
+        for line in basket.lines.all():
+            product = line.product
+            if product.get_product_class() == seat_class:
+                return product
+
+        return None
 
     def handle_processor_response(self, response, basket=None):
         """
@@ -211,3 +222,70 @@ class Cybersource(BasePaymentProcessor):
     def is_signature_valid(self, response):
         """Returns a boolean indicating if the response's signature (indicating potential tampering) is valid."""
         return response and (self._generate_signature(response) == response.get(u'signature'))
+
+    def issue_credit(self, source, amount, currency):
+        order = source.order
+
+        try:
+            order_request_token = source.reference
+
+            security = Security()
+            token = UsernameToken(self.merchant_id, self.transaction_key)
+            security.tokens.append(token)
+
+            client = Client(self.soap_api_url)
+            client.set_options(wsse=security)
+
+            credit_service = client.factory.create('ns0:CCCreditService')
+            credit_service._run = 'true'  # pylint: disable=protected-access
+            credit_service.captureRequestID = source.reference
+
+            purchase_totals = client.factory.create('ns0:PurchaseTotals')
+            purchase_totals.currency = currency
+            purchase_totals.grandTotalAmount = unicode(amount)
+
+            response = client.service.runTransaction(merchantID=self.merchant_id, merchantReferenceCode=order.basket.id,
+                                                     orderRequestToken=order_request_token,
+                                                     ccCreditService=credit_service,
+                                                     purchaseTotals=purchase_totals)
+            request_id = response.requestID
+            ppr = self.record_processor_response(suds_response_to_dict(response), transaction_id=request_id,
+                                                 basket=order.basket)
+        except:
+            msg = 'An error occurred while attempting to issue a credit (via CyberSource) for order [{}].'.format(
+                order.number)
+            logger.exception(msg)
+            raise GatewayError(msg)
+
+        if response.decision == 'ACCEPT':
+            source.refund(amount, reference=request_id)
+            event_type, __ = PaymentEventType.objects.get_or_create(name=PaymentEventTypeName.REFUNDED)
+            PaymentEvent.objects.create(event_type=event_type, order=order, amount=amount, reference=request_id,
+                                        processor_name=self.NAME)
+        else:
+            raise GatewayError(
+                'Failed to issue CyberSource credit for order [{order_number}]. '
+                'Complete response has been recorded in entry [{response_id}]'.format(
+                    order_number=order.number, response_id=ppr.id))
+
+
+def suds_response_to_dict(d):  # pragma: no cover
+    """
+    Convert Suds object into serializable format.
+
+    Source: http://stackoverflow.com/a/15678861/592820
+    """
+    out = {}
+    for k, v in asdict(d).iteritems():
+        if hasattr(v, '__keylist__'):
+            out[k] = suds_response_to_dict(v)
+        elif isinstance(v, list):
+            out[k] = []
+            for item in v:
+                if hasattr(item, '__keylist__'):
+                    out[k].append(suds_response_to_dict(item))
+                else:
+                    out[k].append(item)
+        else:
+            out[k] = v
+    return out

ecommerce/extensions/payment/processors/paypal.py

+""" PayPal payment processing. """
+
 from decimal import Decimal
 import logging
 from urlparse import urljoin
@@ -16,6 +18,7 @@ logger = logging.getLogger(__name__)
 PaymentEvent = get_model('order', 'PaymentEvent')
 PaymentEventType = get_model('order', 'PaymentEventType')
 PaymentProcessorResponse = get_model('payment', 'PaymentProcessorResponse')
+ProductClass = get_model('catalogue', 'ProductClass')
 Source = get_model('payment', 'Source')
 SourceType = get_model('payment', 'SourceType')
 
@@ -26,6 +29,7 @@ class Paypal(BasePaymentProcessor):
 
     For reference, see https://developer.paypal.com/docs/api/.
     """
+
     NAME = u'paypal'
 
     def __init__(self):
@@ -164,7 +168,7 @@ class Paypal(BasePaymentProcessor):
 
             raise GatewayError
 
-        entry = self.record_processor_response(payment.to_dict(), transaction_id=payment.id, basket=basket)
+        self.record_processor_response(payment.to_dict(), transaction_id=payment.id, basket=basket)
         logger.info(u"Successfully executed PayPal payment [%s] for basket [%d].", payment.id, basket.id)
 
         # Get or create Source used to track transactions related to PayPal
@@ -198,3 +202,62 @@ class Paypal(BasePaymentProcessor):
         attribute in this module.
         """
         return payment.error  # pragma: no cover
+
+    def _get_payment_sale(self, payment):
+        """
+        Returns the Sale related to a given Payment.
+
+        Note (CCB): We mostly expect to have a single sale and transaction per payment. If we
+        ever move to a split payment scenario, this will need to be updated.
+        """
+        for transaction in payment.transactions:
+            for related_resource in transaction.related_resources:
+                try:
+                    return related_resource.sale
+                except Exception:   # pylint: disable=broad-except
+                    continue
+
+        return None
+
+    def issue_credit(self, source, amount, currency):
+        order = source.order
+
+        try:
+            payment = paypalrestsdk.Payment.find(source.reference)
+            sale = self._get_payment_sale(payment)
+
+            if not sale:
+                logger.error('Unable to find a Sale associated with PayPal Payment [%s].', payment.id)
+
+            refund = sale.refund({
+                'amount': {
+                    'total': unicode(amount),
+                    'currency': currency,
+                }
+            })
+
+        except:
+            msg = 'An error occurred while attempting to issue a credit (via PayPal) for order [{}].'.format(
+                order.number)
+            logger.exception(msg)
+            raise GatewayError(msg)
+
+        basket = order.basket
+        if refund.success():
+            transaction_id = refund.id
+
+            self.record_processor_response(refund.to_dict(), transaction_id=transaction_id, basket=basket)
+
+            source.refund(amount, reference=transaction_id)
+
+            event_type, __ = PaymentEventType.objects.get_or_create(name=PaymentEventTypeName.REFUNDED)
+            PaymentEvent.objects.create(event_type=event_type, order=order, amount=amount, reference=transaction_id,
+                                        processor_name=self.NAME)
+        else:
+            error = refund.error
+            entry = self.record_processor_response(error, transaction_id=error['debug_id'], basket=basket)
+
+            msg = "Failed to refund PayPal payment [{sale_id}]. " \
+                  "PayPal's response was recorded in entry [{response_id}].".format(sale_id=sale.id,
+                                                                                    response_id=entry.id)
+            raise GatewayError(msg)

ecommerce/extensions/payment/tests/CyberSourceTransaction_1.115.wsdl

+<?xml version="1.0" encoding="utf-8"?>
+<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" name="CyberSourceTransactionWS" targetNamespace="urn:schemas-cybersource-com:transaction-data:TransactionProcessor" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="urn:schemas-cybersource-com:transaction-data:TransactionProcessor" xmlns:data="urn:schemas-cybersource-com:transaction-data-1.115">
+   <wsdl:types>
+      <xsd:schema>
+         <xsd:import namespace="urn:schemas-cybersource-com:transaction-data-1.115" schemaLocation="CyberSourceTransaction_1.115.xsd"/>
+      </xsd:schema>
+   </wsdl:types>
+   <wsdl:message name="messageIn">
+      <wsdl:part name="input" element="data:requestMessage"/>
+   </wsdl:message>
+   <wsdl:message name="messageOut">
+      <wsdl:part name="result" element="data:replyMessage"/>
+   </wsdl:message>
+   <wsdl:portType name="ITransactionProcessor">
+      <wsdl:operation name="runTransaction">
+         <wsdl:input name="inputMessageIn" message="tns:messageIn"/>
+         <wsdl:output name="outputMessageOut" message="tns:messageOut"/>
+      </wsdl:operation>
+   </wsdl:portType>
+   <wsdl:binding name="ITransactionProcessor" type="tns:ITransactionProcessor">
+      <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+      <wsdl:operation name="runTransaction">
+         <soap:operation soapAction="runTransaction" style="document"/>
+         <wsdl:input name="inputMessageIn">
+            <soap:body use="literal"/>
+         </wsdl:input>
+         <wsdl:output name="outputMessageOut">
+            <soap:body use="literal"/>
+         </wsdl:output>
+      </wsdl:operation>
+   </wsdl:binding>
+   <wsdl:service name="TransactionProcessor">
+      <wsdl:documentation>CyberSource Web Service</wsdl:documentation>
+      <wsdl:port name="portXML" binding="tns:ITransactionProcessor">
+         <soap:address location="https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor"/>
+      </wsdl:port>
+   </wsdl:service>
+</wsdl:definitions>

ecommerce/extensions/payment/tests/mixins.py

 import json
+import os
+from urlparse import urljoin
 
 from django.conf import settings
 import httpretty
+import mock
 from oscar.core.loading import get_model
+from suds.sudsobject import Factory
 
 from ecommerce.extensions.payment.constants import CARD_TYPES
 from ecommerce.extensions.payment.helpers import sign
 
-
 Order = get_model('order', 'Order')
 PaymentProcessorResponse = get_model('payment', 'PaymentProcessorResponse')
 
@@ -112,6 +115,38 @@ class CybersourceMixin(object):
         notification[u'signature'] = self.generate_signature(secret_key, notification)
         return notification
 
+    def mock_cybersource_wsdl(self):
+        files = ('CyberSourceTransaction_1.115.wsdl', 'CyberSourceTransaction_1.115.xsd')
+
+        for filename in files:
+            path = os.path.join(os.path.dirname(__file__), filename)
+            body = open(path, 'r').read()
+            url = urljoin(settings.PAYMENT_PROCESSOR_CONFIG['cybersource']['soap_api_url'], filename)
+            httpretty.register_uri(httpretty.GET, url, body=body)
+
+    def get_soap_mock(self, amount=100, currency='GBP', transaction_id=None, basket_id=None, decision='ACCEPT'):
+        class CybersourceSoapMock(mock.MagicMock):
+            def runTransaction(self, **kwargs):     # pylint: disable=unused-argument
+                cc_reply_items = {
+                    'reasonCode': 100,
+                    'amount': unicode(amount),
+                    'requestDateTime': '2015-01-01T:00:00:00Z',
+                    'reconciliationID': 'efg456'
+                }
+                items = {
+                    'requestID': transaction_id,
+                    'decision': decision,
+                    'merchantReferenceCode': unicode(basket_id),
+                    'reasonCode': 100,
+                    'requestToken': 'abc123',
+                    'purchaseTotals': Factory.object('PurchaseTotals', {'currency': currency}),
+                    'ccCreditReply': Factory.object('CCCreditReply', cc_reply_items)
+                }
+
+                return Factory.object('reply', items)
+
+        return CybersourceSoapMock
+
 
 class PaypalMixin(object):
     """Mixin with helper methods for mocking PayPal API responses."""
@@ -180,7 +215,7 @@ class PaypalMixin(object):
             u'state': state,
             u'transactions': [{
                 u'amount': {
-                    u'currency': u'USD',
+                    u'currency': u'GBP',
                     u'details': {u'subtotal': total},
                     u'total': total
                 },
@@ -255,7 +290,7 @@ class PaypalMixin(object):
             u'state': state,
             u'transactions': [{
                 u'amount': {
-                    u'currency': u'USD',
+                    u'currency': u'GBP',
                     u'details': {u'subtotal': total},
                     u'total': total
                 },
@@ -274,7 +309,7 @@ class PaypalMixin(object):
                 u'related_resources': [{
                     u'sale': {
                         u'amount': {
-                            u'currency': u'USD',
+                            u'currency': u'GBP',
                             u'total': total
                         },
                         u'create_time': u'2015-05-04T15:55:27Z',
@@ -306,7 +341,7 @@ class PaypalMixin(object):
                         u'protection_eligibility_type': u'ITEM_NOT_RECEIVED_ELIGIBLE,UNAUTHORIZED_PAYMENT_ELIGIBLE',
                         u'state': u'completed',
                         u'transaction_fee': {
-                            u'currency': u'USD',
+                            u'currency': u'GBP',
                             u'value': u'0.50'
                         },
                         u'update_time': u'2015-05-04T15:58:47Z'

ecommerce/extensions/payment/tests/processors.py

@@ -13,6 +13,9 @@ class DummyProcessor(BasePaymentProcessor):
     def is_signature_valid(self, response):
         pass
 
+    def issue_credit(self, transaction_id, amount, currency):
+        pass
+
 
 class AnotherDummyProcessor(DummyProcessor):
     NAME = 'another-dummy'

ecommerce/extensions/payment/tests/test_views.py

@@ -19,7 +19,6 @@ from ecommerce.extensions.payment.processors.paypal import Paypal
 from ecommerce.extensions.payment.tests.mixins import PaymentEventsMixin, CybersourceMixin, PaypalMixin
 from ecommerce.extensions.payment.views import CybersourceNotifyView, PaypalPaymentExecutionView
 
-
 Basket = get_model('basket', 'Basket')
 Order = get_model('order', 'Order')
 PaymentEvent = get_model('order', 'PaymentEvent')
@@ -220,9 +219,8 @@ class PaypalPaymentExecutionViewTests(PaypalMixin, PaymentEventsMixin, TestCase)
         Verify that a user who has approved payment is redirected to the configured receipt page when payment
         execution fails.
         """
-        with mock.patch.object(
-            PaypalPaymentExecutionView, 'handle_payment', side_effect=PaymentError
-        ) as fake_handle_payment:
+        with mock.patch.object(PaypalPaymentExecutionView, 'handle_payment',
+                               side_effect=PaymentError) as fake_handle_payment:
             self._assert_execution_redirect()
             self.assertTrue(fake_handle_payment.called)
 
@@ -231,8 +229,7 @@ class PaypalPaymentExecutionViewTests(PaypalMixin, PaymentEventsMixin, TestCase)
         Verify that a user who has approved payment is redirected to the configured receipt page when the payment
         is executed but an order cannot be placed.
         """
-        with mock.patch.object(
-            PaypalPaymentExecutionView, 'handle_order_placement', side_effect=UnableToPlaceOrder
-        ) as fake_handle_order_placement:
+        with mock.patch.object(PaypalPaymentExecutionView, 'handle_order_placement',
+                               side_effect=UnableToPlaceOrder) as fake_handle_order_placement:
             self._assert_execution_redirect()
             self.assertTrue(fake_handle_order_placement.called)

ecommerce/extensions/refund/models.py

+import logging
+
 from django.conf import settings
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 from django_extensions.db.models import TimeStampedModel
+from oscar.apps.payment.exceptions import PaymentError
+from oscar.core.loading import get_class
 from oscar.core.utils import get_default_currency
 from simple_history.models import HistoricalRecords
 
+from ecommerce.extensions.fulfillment.api import revoke_fulfillment_for_refund
+from ecommerce.extensions.payment.helpers import get_processor_class_by_name
 from ecommerce.extensions.refund.exceptions import InvalidStatus
-from ecommerce.extensions.refund.status import REFUND
+from ecommerce.extensions.refund.status import REFUND, REFUND_LINE
+
+logger = logging.getLogger(__name__)
+
+post_refund = get_class('refund.signals', 'post_refund')
 
 
 class StatusMixin(object):
@@ -83,6 +93,63 @@ class Refund(StatusMixin, TimeStampedModel):
         """
         return self.status == settings.OSCAR_INITIAL_REFUND_STATUS
 
+    def _issue_credit(self):
+        """ Issue a credit to the purchaser via the payment processor used for the original order. """
+
+        # TODO Update this if we ever support multiple payment sources for a single order.
+        source = self.order.sources.first()
+        processor = get_processor_class_by_name(source.source_type.name)()
+        processor.issue_credit(source, self.total_credit_excl_tax, self.currency)
+
+    def _revoke_lines(self):
+        """ Revoke fulfillment for the lines in this Refund. """
+        if revoke_fulfillment_for_refund(self):
+            self.set_status(REFUND.COMPLETE)
+            logger.info('Successfully revoked fulfillment for Refund [%d]', self.id)
+        else:
+            logger.error('Unable to revoke fulfillment of all lines of Refund [%d].', self.id)
+            self.set_status(REFUND.REVOCATION_ERROR)
+
+    def approve(self):
+        if not self.can_approve:
+            logger.debug('Refund [%d] cannot be approved.', self.id)
+            return False
+        elif self.status in (REFUND.OPEN, REFUND.PAYMENT_REFUND_ERROR):
+            try:
+                self._issue_credit()
+                logger.info('Successfully issued credit for Refund [%d]', self.id)
+                self.set_status(REFUND.PAYMENT_REFUNDED)
+            except PaymentError:
+                logger.exception('Failed to issue credit for refund [%d].', self.id)
+                self.set_status(REFUND.PAYMENT_REFUND_ERROR)
+                return False
+
+        if self.status in (REFUND.PAYMENT_REFUNDED, REFUND.REVOCATION_ERROR):
+            self._revoke_lines()
+
+        if self.status == REFUND.COMPLETE:
+            post_refund.send(sender=self.__class__, refund=self)
+            return True
+
+        return False
+
+    def deny(self):
+        if not self.can_deny:
+            logger.debug('Refund [%d] cannot be denied.', self.id)
+            return False
+
+        self.set_status(REFUND.DENIED)
+
+        result = True
+        for line in self.lines.all():
+            try:
+                line.deny()
+            except Exception:  # pylint: disable=broad-except
+                logger.exception('Failed to deny RefundLine [%d].', line.id)
+                result = False
+
+        return result
+
 
 class RefundLine(StatusMixin, TimeStampedModel):
     """A refund line, used to represent the state of a single item as part of a larger Refund."""
@@ -94,3 +161,7 @@ class RefundLine(StatusMixin, TimeStampedModel):
 
     history = HistoricalRecords()
     pipeline_setting = 'OSCAR_REFUND_LINE_STATUS_PIPELINE'
+
+    def deny(self):
+        self.set_status(REFUND_LINE.DENIED)
+        return True

ecommerce/extensions/refund/signals.py

+from django.dispatch import Signal
+
+# This signal should be emitted after a refund is completed--payment credited AND fulfillment revoked.
+post_refund = Signal(providing_args=["refund"])
+
+# TODO Track refund: https://support.google.com/analytics/answer/1037443?hl=en

ecommerce/extensions/refund/status.py

 class REFUND(object):
     OPEN = 'Open'
     DENIED = 'Denied'
-    ERROR = 'Error'
+    PAYMENT_REFUND_ERROR = 'Payment Refund Error'
+    PAYMENT_REFUNDED = 'Payment Refunded'
+    REVOCATION_ERROR = 'Revocation Error'
     COMPLETE = 'Complete'
 
 
 class REFUND_LINE(object):
     OPEN = 'Open'
-    PAYMENT_REFUND_ERROR = 'Payment Refund Error'
-    PAYMENT_REFUNDED = 'Payment Refunded'
     REVOCATION_ERROR = 'Revocation Error'
     DENIED = 'Denied'
     COMPLETE = 'Complete'

ecommerce/extensions/refund/tests/factories.py

@@ -25,6 +25,17 @@ class RefundFactory(factory.DjangoModelFactory):
     def order(self):
         return factories.create_order(user=self.user)
 
+    @factory.post_generation
+    def create_lines(self, create, extracted, **kwargs):    # pylint: disable=unused-argument
+        if not create:
+            return
+
+        for __ in range(2):
+            RefundLineFactory.create(refund=self)
+
+        self.total_credit_excl_tax = sum([line.line_credit_excl_tax for line in self.lines.all()])
+        self.save()
+
     class Meta(object):
         model = get_model('refund', 'Refund')
 

ecommerce/extensions/refund/tests/mixins.py

+from oscar.core.loading import get_model
+
+from ecommerce.extensions.refund.tests.factories import RefundFactory
+
+Source = get_model('payment', 'Source')
+SourceType = get_model('payment', 'SourceType')
+
+
+class RefundTestMixin(object):
+    def create_refund(self, processor_name='cybersource'):
+        refund = RefundFactory()
+        order = refund.order
+        source_type, __ = SourceType.objects.get_or_create(name=processor_name)
+        Source.objects.create(source_type=source_type, order=order, currency=refund.currency,
+                              amount_allocated=order.total_incl_tax, amount_debited=order.total_incl_tax)
+
+        return refund

ecommerce/extensions/refund/tests/test_models.py

 import ddt
-from django.test import TestCase, override_settings
-from oscar.core.loading import get_model
-
+from django.conf import settings
+from django.test import TestCase
+import mock
+from mock_django import mock_signal_receiver
+from oscar.apps.payment.exceptions import PaymentError
+from oscar.core.loading import get_model, get_class
+
+from ecommerce.extensions.refund import models
 from ecommerce.extensions.refund.exceptions import InvalidStatus
 from ecommerce.extensions.refund.status import REFUND, REFUND_LINE
 from ecommerce.extensions.refund.tests.factories import RefundFactory, RefundLineFactory
 
-OSCAR_REFUND_STATUS_PIPELINE = {
-    REFUND.OPEN: (REFUND.DENIED, REFUND.ERROR, REFUND.COMPLETE),
-    REFUND.ERROR: (REFUND.COMPLETE, REFUND.ERROR),
-    REFUND.DENIED: (),
-    REFUND.COMPLETE: ()
-}
-
-OSCAR_REFUND_LINE_STATUS_PIPELINE = {
-    REFUND_LINE.OPEN: (REFUND_LINE.DENIED, REFUND_LINE.PAYMENT_REFUND_ERROR, REFUND_LINE.PAYMENT_REFUNDED),
-    REFUND_LINE.PAYMENT_REFUND_ERROR: (REFUND_LINE.PAYMENT_REFUNDED,),
-    REFUND_LINE.PAYMENT_REFUNDED: (REFUND_LINE.COMPLETE, REFUND_LINE.REVOCATION_ERROR),
-    REFUND_LINE.REVOCATION_ERROR: (REFUND_LINE.COMPLETE,),
-    REFUND_LINE.DENIED: (),
-    REFUND_LINE.COMPLETE: ()
-}
-
+post_refund = get_class('refund.signals', 'post_refund')
 Refund = get_model('refund', 'Refund')
 
 
@@ -64,30 +54,30 @@ class StatusTestsMixin(object):
 
 
 @ddt.ddt
-@override_settings(OSCAR_REFUND_STATUS_PIPELINE=OSCAR_REFUND_STATUS_PIPELINE, OSCAR_INITIAL_REFUND_STATUS=REFUND.OPEN)
 class RefundTests(StatusTestsMixin, TestCase):
-    pipeline = OSCAR_REFUND_STATUS_PIPELINE
+    pipeline = settings.OSCAR_REFUND_STATUS_PIPELINE
 
     def _get_instance(self, **kwargs):
         return RefundFactory(**kwargs)
 
     def test_num_items(self):
         """ The method should return the total number of items being refunded. """
-        refund_line = RefundLineFactory(quantity=1)
-        refund = refund_line.refund
-        self.assertEqual(refund.num_items, 1)
+        refund = RefundFactory()
+        self.assertEqual(refund.num_items, 2)
 
         RefundLineFactory(quantity=3, refund=refund)
-        self.assertEqual(refund.num_items, 4)
+        self.assertEqual(refund.num_items, 5)
 
     def test_all_statuses(self):
         """ Refund.all_statuses should return all possible statuses for a refund. """
-        self.assertEqual(Refund.all_statuses(), OSCAR_REFUND_STATUS_PIPELINE.keys())
+        self.assertEqual(Refund.all_statuses(), self.pipeline.keys())
 
     @ddt.unpack
     @ddt.data(
         (REFUND.OPEN, True),
-        (REFUND.ERROR, True),
+        (REFUND.PAYMENT_REFUND_ERROR, True),
+        (REFUND.PAYMENT_REFUNDED, True),
+        (REFUND.REVOCATION_ERROR, True),
         (REFUND.DENIED, False),
         (REFUND.COMPLETE, False),
     )
@@ -99,7 +89,7 @@ class RefundTests(StatusTestsMixin, TestCase):
     @ddt.unpack
     @ddt.data(
         (REFUND.OPEN, True),
-        (REFUND.ERROR, False),
+        (REFUND.REVOCATION_ERROR, False),
         (REFUND.DENIED, False),
         (REFUND.COMPLETE, False),
     )
@@ -108,10 +98,107 @@ class RefundTests(StatusTestsMixin, TestCase):
         refund = self._get_instance(status=status)
         self.assertEqual(refund.can_deny, expected)
 
+    def assert_line_status(self, refund, status):
+        for line in refund.lines.all():
+            self.assertEqual(line.status, status)
+
+    def test_approve(self):
+        """
+        If payment refund and fulfillment revocation succeed, the method should update the status of the Refund and
+        RefundLine objects to Complete, and return True.
+        """
+        refund = self._get_instance()
+
+        def _revoke_lines(r):
+            for line in r.lines.all():
+                line.set_status(REFUND_LINE.COMPLETE)
+
+            r.set_status(REFUND.COMPLETE)
+
+        with mock.patch.object(Refund, '_issue_credit', return_value=None):
+            with mock.patch.object(Refund, '_revoke_lines', side_effect=_revoke_lines, autospec=True):
+                with mock_signal_receiver(post_refund) as receiver:
+                    self.assertEqual(receiver.call_count, 0)
+                    self.assertTrue(refund.approve())
+                    self.assertEqual(receiver.call_count, 1)
+
+    def test_approve_payment_error(self):
+        """
+        If payment refund fails, the Refund status should be set to Payment Refund Error, and the RefundLine
+        objects' statuses to Open.
+        """
+        refund = self._get_instance()
+
+        with mock.patch.object(Refund, '_issue_credit', side_effect=PaymentError):
+            self.assertFalse(refund.approve())
+            self.assertEqual(refund.status, REFUND.PAYMENT_REFUND_ERROR)
+            self.assert_line_status(refund, REFUND_LINE.OPEN)
+
+    def test_approve_revocation_error(self):
+        """
+        If fulfillment revocation fails, Refund status should be set to Revocation Error and the RefundLine objects'
+        statuses set to Revocation Error.
+        """
+        refund = self._get_instance()
+
+        def revoke_fulfillment_for_refund(r):
+            for line in r.lines.all():
+                line.set_status(REFUND_LINE.REVOCATION_ERROR)
+
+            return False
+
+        with mock.patch.object(Refund, '_issue_credit', return_value=None):
+            with mock.patch.object(models, 'revoke_fulfillment_for_refund') as mock_revoke:
+                mock_revoke.side_effect = revoke_fulfillment_for_refund
+                self.assertFalse(refund.approve())
+                self.assertEqual(refund.status, REFUND.REVOCATION_ERROR)
+                self.assert_line_status(refund, REFUND_LINE.REVOCATION_ERROR)
+
+    @ddt.data(REFUND.COMPLETE, REFUND.DENIED)
+    def test_approve_wrong_state(self, status):
+        """ The method should return False if the Refund cannot be approved. """
+        refund = self._get_instance(status=status)
+        self.assertEqual(refund.status, status)
+        self.assert_line_status(refund, REFUND_LINE.OPEN)
+
+        self.assertFalse(refund.approve())
+        self.assertEqual(refund.status, status)
+        self.assert_line_status(refund, REFUND_LINE.OPEN)
+
+    def test_deny(self):
+        """
+        The method should update the state of the Refund and related RefundLine objects, if the Refund can be
+        denied, and return True.
+        """
+        refund = self._get_instance()
+        self.assertEqual(refund.status, REFUND.OPEN)
+        self.assert_line_status(refund, REFUND_LINE.OPEN)
+
+        self.assertTrue(refund.deny())
+        self.assertEqual(refund.status, REFUND.DENIED)
+        self.assert_line_status(refund, REFUND_LINE.DENIED)
+
+    @ddt.data(REFUND.REVOCATION_ERROR, REFUND.PAYMENT_REFUNDED, REFUND.PAYMENT_REFUND_ERROR, REFUND.COMPLETE)
+    def test_deny_wrong_state(self, status):
+        """ The method should return False if the Refund cannot be denied. """
+        refund = self._get_instance(status=status)
+        self.assertEqual(refund.status, status)
+        self.assert_line_status(refund, REFUND_LINE.OPEN)
+
+        self.assertFalse(refund.deny())
+        self.assertEqual(refund.status, status)
+        self.assert_line_status(refund, REFUND_LINE.OPEN)
+
 
-@override_settings(OSCAR_REFUND_LINE_STATUS_PIPELINE=OSCAR_REFUND_LINE_STATUS_PIPELINE)
 class RefundLineTests(StatusTestsMixin, TestCase):
-    pipeline = OSCAR_REFUND_LINE_STATUS_PIPELINE
+    pipeline = settings.OSCAR_REFUND_LINE_STATUS_PIPELINE
 
     def _get_instance(self, **kwargs):
         return RefundLineFactory(**kwargs)
+
+    def test_deny(self):
+        """ The method sets the status to Denied. """
+        line = self._get_instance()
+        self.assertEqual(line.status, REFUND_LINE.OPEN)
+        self.assertTrue(line.deny())
+        self.assertEqual(line.status, REFUND_LINE.DENIED)

ecommerce/settings/_oscar.py

@@ -133,17 +133,17 @@ OSCAR_INITIAL_REFUND_STATUS = REFUND.OPEN
 OSCAR_INITIAL_REFUND_LINE_STATUS = REFUND_LINE.OPEN
 
 OSCAR_REFUND_STATUS_PIPELINE = {
-    REFUND.OPEN: (REFUND.DENIED, REFUND.ERROR, REFUND.COMPLETE),
-    REFUND.ERROR: (REFUND.COMPLETE, REFUND.ERROR),
+    REFUND.OPEN: (REFUND.DENIED, REFUND.PAYMENT_REFUND_ERROR, REFUND.PAYMENT_REFUNDED),
+    REFUND.PAYMENT_REFUND_ERROR: (REFUND.PAYMENT_REFUNDED, REFUND.PAYMENT_REFUND_ERROR),
+    REFUND.PAYMENT_REFUNDED: (REFUND.REVOCATION_ERROR, REFUND.COMPLETE),
+    REFUND.REVOCATION_ERROR: (REFUND.REVOCATION_ERROR, REFUND.COMPLETE),
     REFUND.DENIED: (),
     REFUND.COMPLETE: ()
 }
 
 OSCAR_REFUND_LINE_STATUS_PIPELINE = {
-    REFUND_LINE.OPEN: (REFUND_LINE.DENIED, REFUND_LINE.PAYMENT_REFUND_ERROR, REFUND_LINE.PAYMENT_REFUNDED),
-    REFUND_LINE.PAYMENT_REFUND_ERROR: (REFUND_LINE.PAYMENT_REFUNDED, REFUND_LINE.PAYMENT_REFUND_ERROR),
-    REFUND_LINE.PAYMENT_REFUNDED: (REFUND_LINE.COMPLETE, REFUND_LINE.REVOCATION_ERROR),
-    REFUND_LINE.REVOCATION_ERROR: (REFUND_LINE.COMPLETE, REFUND_LINE.REVOCATION_ERROR),
+    REFUND_LINE.OPEN: (REFUND_LINE.DENIED, REFUND_LINE.REVOCATION_ERROR, REFUND_LINE.COMPLETE),
+    REFUND_LINE.REVOCATION_ERROR: (REFUND_LINE.REVOCATION_ERROR, REFUND_LINE.COMPLETE),
     REFUND_LINE.DENIED: (),
     REFUND_LINE.COMPLETE: ()
 }
@@ -225,3 +225,6 @@ OSCAR_DASHBOARD_NAVIGATION = [
     },
 ]
 # END DASHBOARD NAVIGATION MENU
+
+# Default timeout for Enrollment API calls
+ENROLLMENT_FULFILLMENT_TIMEOUT = 5

ecommerce/settings/local.py

@@ -94,7 +94,7 @@ JWT_AUTH['JWT_SECRET_KEY'] = 'insecure-secret-key'
 
 # ORDER PROCESSING
 ENROLLMENT_API_URL = get_lms_url('/api/enrollment/v1/enrollment')
-ENROLLMENT_FULFILLMENT_TIMEOUT = 15     # devstack is slow!
+ENROLLMENT_FULFILLMENT_TIMEOUT = 15  # devstack is slow!
 
 EDX_API_KEY = 'replace-me'
 # END ORDER PROCESSING
@@ -103,10 +103,13 @@ EDX_API_KEY = 'replace-me'
 # PAYMENT PROCESSING
 PAYMENT_PROCESSOR_CONFIG = {
     'cybersource': {
+        'soap_api_url': 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor/CyberSourceTransaction_1.115.wsdl',
+        'merchant_id': 'fake-merchant-id',
+        'transaction_key': 'fake-transaction-key',
         'profile_id': 'fake-profile-id',
         'access_key': 'fake-access-key',
         'secret_key': 'fake-secret-key',
-        'payment_page_url': 'https://replace-me/',
+        'payment_page_url': 'https://testsecureacceptance.cybersource.com/pay',
         'receipt_page_url': get_lms_url('/commerce/checkout/receipt/'),
         'cancel_page_url': get_lms_url('/commerce/checkout/cancel/'),
     },

ecommerce/settings/logger.py

@@ -73,6 +73,16 @@ def get_logger_config(log_dir='/var/tmp',
                 'propagate': True,
                 'level': 'WARNING'
             },
+            'suds': {
+                'handlers': handlers,
+                'propagate': True,
+                'level': 'WARNING'
+            },
+            'factory': {
+                'handlers': handlers,
+                'propagate': True,
+                'level': 'WARNING'
+            },
             'django.request': {
                 'handlers': handlers,
                 'propagate': True,

ecommerce/settings/test.py

@@ -3,6 +3,7 @@ from __future__ import absolute_import
 import os
 
 from ecommerce.settings.base import *
+from ecommerce.settings.logger import get_logger_config
 
 
 # TEST SETTINGS
@@ -12,6 +13,8 @@ INSTALLED_APPS += (
 
 TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'
 
+LOGGING = get_logger_config(debug=DEBUG, dev_env=True, local_loglevel='DEBUG')
+
 
 class DisableMigrations(object):
     """Override method calls on the MIGRATION_MODULES dictionary.
@@ -85,6 +88,9 @@ EDX_API_KEY = 'replace-me'
 # PAYMENT PROCESSING
 PAYMENT_PROCESSOR_CONFIG = {
     'cybersource': {
+        'soap_api_url': 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor/CyberSourceTransaction_1.115.wsdl',
+        'merchant_id': 'fake-merchant-id',
+        'transaction_key': 'fake-transaction-key',
         'profile_id': 'fake-profile-id',
         'access_key': 'fake-access-key',
         'secret_key': 'fake-secret-key',

requirements/base.txt

@@ -12,3 +12,4 @@ jsonfield==1.0.3
 paypalrestsdk==1.9.0
 pycountry==1.10
 requests==2.6.0
+suds==0.4

requirements/test.txt

@@ -8,9 +8,11 @@ django-nose==1.3
 django_dynamic_fixture==1.8.1
 httpretty==0.8.8
 mock==1.0.1
+mock-django==0.6.8
 nose-ignore-docstring==0.2
 pep8==1.6.2
 pylint==1.4.1
 selenium==2.45.0
+testfixtures==4.1.2
 
 git+https://github.com/edx/ecommerce-api-client.git@1.0.0#egg=ecommerce-api-client==1.0.0