Merge pull request #104 from edx/refund-payment-credit

Added Support for Processing Refunds

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