Merge branch 'zoldak/certificates-acceptance-tests' into ormsbee/verifyuser3

common/djangoapps/course_modes/tests/factories.py

+from course_modes.models import CourseMode
+from factory import DjangoModelFactory
+
+# Factories don't have __init__ methods, and are self documenting
+# pylint: disable=W0232
+class CourseModeFactory(DjangoModelFactory):
+    FACTORY_FOR = CourseMode
+
+    course_id = u'MITx/999/Robot_Super_Course'
+    mode_slug = 'audit'
+    mode_display_name = 'audit course'
+    min_price = 0
+    currency = 'usd'

common/djangoapps/terrain/factories.py

@@ -5,6 +5,7 @@ and integration / BDD tests.
 '''
 import student.tests.factories as sf
 import xmodule.modulestore.tests.factories as xf
+import course_modes.tests.factories as cmf
 from lettuce import world
 
 
@@ -52,6 +53,14 @@ class CourseEnrollmentAllowedFactory(sf.CourseEnrollmentAllowedFactory):
 
 
 @world.absorb
+class CourseModeFactory(cmf.CourseModeFactory):
+    """
+    Course modes
+    """
+    pass
+
+
+@world.absorb
 class CourseFactory(xf.CourseFactory):
     """
     Courseware courses

lms/djangoapps/courseware/features/certificates.feature

+Feature: Verified certificates
+    As a student,
+    In order to earn a verified certificate
+    I want to sign up for a verified certificate course.
+
+    Scenario: I can audit a verified certificate course
+        Given I am logged in
+        When I select the audit track
+        Then I should see the course on my dashboard
+
+    Scenario: I can submit photos to verify my identity
+        Given I am logged in
+        When I select the verified track
+        And I go to step "1"
+        And I capture my "face" photo
+        And I approve my "face" photo
+        And I go to step "2"
+        And I capture my "photo_id" photo
+        And I approve my "photo_id" photo
+        And I go to step "3"
+        And I select a contribution amount
+        And I confirm that the details match
+        And I go to step "4"
+        Then I am at the payment page
+
+    Scenario: I can pay for a verified certificate
+        Given I have submitted photos to verify my identity
+        When I submit valid payment information
+        Then I see that my payment was successful
+
+    Scenario: Verified courses display correctly on dashboard
+        Given I have submitted photos to verify my identity
+        When I submit valid payment information
+        And I navigate to my dashboard
+        Then I see the course on my dashboard
+        And I see that I am on the verified track
+
+    Scenario: I can re-take photos
+        Given I have submitted my "<PhotoType>" photo
+        When I retake my "<PhotoType>" photo
+        Then I see the new photo on the confirmation page.
+
+        Examples:
+        | PhotoType     |
+        | face          |
+        | ID            |
+
+    Scenario: I can edit identity information
+        Given I have submitted face and ID photos
+        When I edit my name
+        Then I see the new name on the confirmation page.
+
+    Scenario: I can return to the verify flow
+        Given I have submitted photos
+        When I leave the flow and return
+        I see the payment page
+
+
+    # Design not yet finalized
+    #Scenario: I can take a verified certificate course for free
+    #    Given I have submitted photos to verify my identity
+    #    When I give a reason why I cannot pay
+    #    Then I see that I am registered for a verified certificate course on my dashboard

lms/djangoapps/courseware/features/certificates.py

+#pylint: disable=C0111
+#pylint: disable=W0621
+
+from lettuce import world, step
+from lettuce.django import django_url
+from course_modes.models import CourseMode
+from nose.tools import assert_equal
+
+def create_cert_course():
+    world.clear_courses()
+    org = 'edx'
+    number = '999'
+    name = 'Certificates'
+    course_id = '{org}/{number}/{name}'.format(
+        org=org, number=number, name=name)
+    world.scenario_dict['COURSE'] = world.CourseFactory.create(
+        org=org, number=number, display_name=name)
+
+    audit_mode = world.CourseModeFactory.create(
+        course_id=course_id,
+        mode_slug='audit',
+        mode_display_name='audit course',
+        min_price=0,
+        )
+    assert isinstance(audit_mode, CourseMode)
+
+    verfied_mode = world.CourseModeFactory.create(
+        course_id=course_id,
+        mode_slug='verified',
+        mode_display_name='verified cert course',
+        min_price=16,
+        suggested_prices='32,64,128',
+        currency='usd',
+        )
+    assert isinstance(verfied_mode, CourseMode)
+
+
+def register():
+    url = 'courses/{org}/{number}/{name}/about'.format(
+        org='edx', number='999', name='Certificates')
+    world.browser.visit(django_url(url))
+
+    world.css_click('section.intro a.register')
+    assert world.is_css_present('section.wrapper h3.title')
+
+
+@step(u'I select the audit track$')
+def select_the_audit_track(step):
+    create_cert_course()
+    register()
+    btn_css = 'input[value="Select Audit"]'
+    world.css_click(btn_css)
+
+
+def select_contribution(amount=32):
+    radio_css = 'input[value="{}"]'.format(amount)
+    world.css_click(radio_css)
+    assert world.css_find(radio_css).selected
+
+
+@step(u'I select the verified track$')
+def select_the_verified_track(step):
+    create_cert_course()
+    register()
+    select_contribution(32)
+    btn_css = 'input[value="Select Certificate"]'
+    world.css_click(btn_css)
+    assert world.is_css_present('section.progress')
+
+
+@step(u'I should see the course on my dashboard$')
+def should_see_the_course_on_my_dashboard(step):
+    course_css = 'article.my-course'
+    assert world.is_css_present(course_css)
+
+
+@step(u'I go to step "([^"]*)"$')
+def goto_next_step(step, step_num):
+    btn_css = {
+        '1': '#face_next_button',
+        '2': '#face_next_button',
+        '3': '#photo_id_next_button',
+        '4': '#pay_button',
+    }
+    next_css = {
+        '1': 'div#wrapper-facephoto.carousel-active',
+        '2': 'div#wrapper-idphoto.carousel-active',
+        '3': 'div#wrapper-review.carousel-active',
+        '4': 'div#wrapper-review.carousel-active',
+    }
+    world.css_click(btn_css[step_num])
+
+    # Pressing the button will advance the carousel to the next item
+    # and give the wrapper div the "carousel-active" class
+    assert world.css_find(next_css[step_num])
+
+
+@step(u'I capture my "([^"]*)" photo$')
+def capture_my_photo(step, name):
+
+    # Draw a red rectangle in the image element
+    snapshot_script = '"{}{}{}{}{}{}"'.format(
+        "var canvas = $('#{}_canvas');".format(name),
+        "var ctx = canvas[0].getContext('2d');",
+        "ctx.fillStyle = 'rgb(200,0,0)';",
+        "ctx.fillRect(0, 0, 640, 480);",
+        "var image = $('#{}_image');".format(name),
+        "image[0].src = canvas[0].toDataURL('image/png').replace('image/png', 'image/octet-stream');"
+        )
+
+    # Mirror the javascript of the photo_verification.html page
+    world.browser.execute_script(snapshot_script)
+    world.browser.execute_script("$('#{}_capture_button').hide();".format(name))
+    world.browser.execute_script("$('#{}_reset_button').show();".format(name))
+    world.browser.execute_script("$('#{}_approve_button').show();".format(name))
+    assert world.css_find('#{}_approve_button'.format(name))
+
+
+@step(u'I approve my "([^"]*)" photo$')
+def approve_my_photo(step, name):
+    button_css = {
+        'face': 'div#wrapper-facephoto li.control-approve',
+        'photo_id': 'div#wrapper-idphoto li.control-approve',
+    }
+    wrapper_css = {
+        'face': 'div#wrapper-facephoto',
+        'photo_id': 'div#wrapper-idphoto',
+    }
+
+    # Make sure that the carousel is in the right place
+    assert world.css_has_class(wrapper_css[name], 'carousel-active')
+    assert world.css_find(button_css[name])
+
+    # HACK: for now don't bother clicking the approve button for
+    # id_photo, because it is sending you back to Step 1.
+    # Come back and figure it out later. JZ Aug 29 2013
+    if name=='face':
+        world.css_click(button_css[name])
+
+    # Make sure you didn't advance the carousel
+    assert world.css_has_class(wrapper_css[name], 'carousel-active')
+
+
+@step(u'I select a contribution amount$')
+def select_contribution_amount(step):
+    select_contribution(32)
+
+
+@step(u'I confirm that the details match$')
+def confirm_details_match(step):
+    # First you need to scroll down on the page
+    # to make the element visible?
+    # Currently chrome is failing with ElementNotVisibleException
+    world.browser.execute_script("window.scrollTo(0,1024)")
+
+    cb_css = 'input#confirm_pics_good'
+    world.css_check(cb_css)
+    assert world.css_find(cb_css).checked
+
+
+@step(u'I am at the payment page')
+def at_the_payment_page(step):
+    assert world.css_find('input[name=transactionSignature]')
+
+
+@step(u'I submit valid payment information$')
+def submit_payment(step):
+    button_css = 'input[value=Submit]'
+    world.css_click(button_css)
+
+
+@step(u'I have submitted photos to verify my identity')
+def submitted_photos_to_verify_my_identity(step):
+    step.given('I am logged in')
+    step.given('I select the verified track')
+    step.given('I go to step "1"')
+    step.given('I capture my "face" photo')
+    step.given('I approve my "face" photo')
+    step.given('I go to step "2"')
+    step.given('I capture my "photo_id" photo')
+    step.given('I approve my "photo_id" photo')
+    step.given('I go to step "3"')
+    step.given('I select a contribution amount')
+    step.given('I confirm that the details match')
+    step.given('I go to step "4"')
+
+
+@step(u'I see that my payment was successful')
+def see_that_my_payment_was_successful(step):
+    world.css_find('div')
+    assert_equal(world.browser.title, u'Receipt for Order 1')
+
+
+@step(u'I navigate to my dashboard')
+def navigate_to_my_dashboard(step):
+    world.css_click('span.avatar')
+    assert world.css_find('section.my-courses')
+
+
+@step(u'I see the course on my dashboard')
+def see_the_course_on_my_dashboard(step):
+    course_link_css = 'section.my-courses a[href*="edx/999/Certificates"]'
+    assert world.is_css_present(course_link_css)
+
+
+@step(u'I see that I am on the verified track')
+def see_that_i_am_on_the_verified_track(step):
+    assert False, 'Implement this step after the design is done'
+
+
+@step(u'I have submitted my "([^"]*)" photo')
+def submitted_my_foo_photo(step, name):
+    assert False, 'This step must be implemented'
+@step(u'I retake my "([^"]*)" photo')
+def retake_my_group1_photo(step, group1):
+    assert False, 'This step must be implemented'
+@step(u'I see the new photo on the confirmation page.')
+def sesee_the_new_photo_on_the_confirmation_page(step):
+    assert False, 'This step must be implemented'
+@step(u'I have submitted face and ID photos')
+def submitted_face_and_id_photos(step):
+    assert False, 'This step must be implemented'
+@step(u'I edit my name')
+def edit_my_name(step):
+    assert False, 'This step must be implemented'
+@step(u'I see the new name on the confirmation page.')
+def sesee_the_new_name_on_the_confirmation_page(step):
+    assert False, 'This step must be implemented'
+@step(u'I have submitted photos')
+def submitted_photos(step):
+    assert False, 'This step must be implemented'
+@step(u'I leave the flow and return')
+def leave_the_flow_and_return(step):
+    assert False, 'This step must be implemented'
+@step(u'I see the payment page')
+def see_the_payment_page(step):
+    assert False, 'This step must be implemented'
+@step(u'I am registered for the course')
+def seam_registered_for_the_course(step):
+    assert False, 'This step must be implemented'
+@step(u'I return to the student dashboard')
+def return_to_the_student_dashboard(step):
+    assert False, 'This step must be implemented'

lms/djangoapps/shoppingcart/tests/payment_fake.py

+"""
+Fake payment page for use in acceptance tests.
+This view is enabled in the URLs by the feature flag `ENABLE_PAYMENT_FAKE`.
+
+Note that you will still need to configure this view as the payment
+processor endpoint in order for the shopping cart to use it:
+
+    settings.CC_PROCESSOR['CyberSource']['PURCHASE_ENDPOINT'] = "/shoppingcart/payment_fake"
+
+You can configure the payment to indicate success or failure by sending a PUT
+request to the view with param "success"
+set to "success" or "failure".  The view defaults to payment success.
+"""
+
+from django.views.generic.base import View
+from django.views.decorators.csrf import csrf_exempt
+from django.http import HttpResponse, HttpResponseBadRequest
+from mitxmako.shortcuts import render_to_response
+
+
+# We use the same hashing function as the software under test,
+# because it mainly uses standard libraries, and I want
+# to avoid duplicating that code.
+from shoppingcart.processors.CyberSource import processor_hash
+
+
+class PaymentFakeView(View):
+    """
+    Fake payment page for use in acceptance tests.
+    """
+
+    # We store the payment status to respond with in a class
+    # variable.  In a multi-process Django app, this wouldn't work,
+    # since processes don't share memory.  Since Lettuce
+    # runs one Django server process, this works for acceptance testing.
+    PAYMENT_STATUS_RESPONSE = "success"
+
+    @csrf_exempt
+    def dispatch(self, *args, **kwargs):
+        """
+        Disable CSRF for these methods.
+        """
+        return super(PaymentFakeView, self).dispatch(*args, **kwargs)
+
+    def post(self, request):
+        """
+        Render a fake payment page.
+
+        This is an HTML form that:
+
+        * Triggers a POST to `postpay_callback()` on submit.
+
+        * Has hidden fields for all the data CyberSource sends to the callback.
+            - Most of this data is duplicated from the request POST params (e.g. `amount` and `course_id`)
+            - Other params contain fake data (always the same user name and address.
+            - Still other params are calculated (signatures)
+
+        * Serves an error page (HTML) with a 200 status code
+          if the signatures are invalid.  This is what CyberSource does.
+
+        Since all the POST requests are triggered by HTML forms, this is
+        equivalent to the CyberSource payment page, even though it's
+        served by the shopping cart app.
+        """
+        if self._is_signature_valid(request.POST):
+            return self._payment_page_response(request.POST, '/shoppingcart/postpay_callback/')
+
+        else:
+            return render_to_response('shoppingcart/test/fake_payment_error.html')
+
+    def put(self, request):
+        """
+        Set the status of payment requests to success or failure.
+
+        Accepts one POST param "status" that can be either "success"
+        or "failure".
+        """
+        new_status = request.body
+
+        if not new_status in ["success", "failure"]:
+            return HttpResponseBadRequest()
+
+        else:
+            # Configure all views to respond with the new status
+            PaymentFakeView.PAYMENT_STATUS_RESPONSE = new_status
+            return HttpResponse()
+
+    @staticmethod
+    def _is_signature_valid(post_params):
+        """
+        Return a bool indicating  whether the client sent
+        us a valid signature in the payment page request.
+        """
+
+        # Calculate the fields signature
+        fields_sig = processor_hash(post_params.get('orderPage_signedFields'))
+
+        # Retrieve the list of signed fields
+        signed_fields = post_params.get('orderPage_signedFields').split(',')
+
+        # Calculate the public signature
+        hash_val = ",".join([
+            "{0}={1}".format(key, post_params[key])
+            for key in signed_fields
+        ]) + ",signedFieldsPublicSignature={0}".format(fields_sig)
+
+        public_sig = processor_hash(hash_val)
+
+        return public_sig == post_params.get('orderPage_signaturePublic')
+
+    @classmethod
+    def response_post_params(cls, post_params):
+        """
+        Calculate the POST params we want to send back to the client.
+        """
+        resp_params = {
+            # Indicate whether the payment was successful
+            "decision": "ACCEPT" if cls.PAYMENT_STATUS_RESPONSE == "success" else "REJECT",
+
+            # Reflect back whatever the client sent us,
+            # defaulting to `None` if a paramter wasn't received
+            "course_id": post_params.get('course_id'),
+            "orderAmount": post_params.get('amount'),
+            "ccAuthReply_amount": post_params.get('amount'),
+            "orderPage_transactionType": post_params.get('orderPage_transactionType'),
+            "orderPage_serialNumber": post_params.get('orderPage_serialNumber'),
+            "orderNumber": post_params.get('orderNumber'),
+            "orderCurrency": post_params.get('currency'),
+            "match": post_params.get('match'),
+            "merchantID": post_params.get('merchantID'),
+
+            # Send fake user data
+            "billTo_firstName": "John",
+            "billTo_lastName": "Doe",
+            "billTo_street1": "123 Fake Street",
+            "billTo_state": "MA",
+            "billTo_city": "Boston",
+            "billTo_postalCode": "02134",
+            "billTo_country": "us",
+
+            # Send fake data for other fields
+            "card_cardType": "001",
+            "card_accountNumber": "############1111",
+            "card_expirationMonth": "08",
+            "card_expirationYear": "2019",
+            "paymentOption": "card",
+            "orderPage_environment": "TEST",
+            "orderPage_requestToken": "unused",
+            "reconciliationID": "39093601YKVO1I5D",
+            "ccAuthReply_authorizationCode": "888888",
+            "ccAuthReply_avsCodeRaw": "I1",
+            "reasonCode": "100",
+            "requestID": "3777139938170178147615",
+            "ccAuthReply_reasonCode": "100",
+            "ccAuthReply_authorizedDateTime": "2013-08-28T181954Z",
+            "ccAuthReply_processorResponse": "100",
+            "ccAuthReply_avsCode": "X",
+
+            # We don't use these signatures
+            "transactionSignature": "unused=",
+            "decision_publicSignature": "unused=",
+            "orderAmount_publicSignature": "unused=",
+            "orderNumber_publicSignature": "unused=",
+            "orderCurrency_publicSignature": "unused=",
+        }
+
+        # Indicate which fields we are including in the signature
+        # Order is important
+        signed_fields = [
+            'billTo_lastName', 'orderAmount', 'course_id',
+            'billTo_street1', 'card_accountNumber', 'orderAmount_publicSignature',
+            'orderPage_serialNumber', 'orderCurrency', 'reconciliationID',
+            'decision', 'ccAuthReply_processorResponse', 'billTo_state',
+            'billTo_firstName', 'card_expirationYear', 'billTo_city',
+            'billTo_postalCode', 'orderPage_requestToken', 'ccAuthReply_amount',
+            'orderCurrency_publicSignature', 'orderPage_transactionType',
+            'ccAuthReply_authorizationCode', 'decision_publicSignature',
+            'match', 'ccAuthReply_avsCodeRaw', 'paymentOption',
+            'billTo_country', 'reasonCode', 'ccAuthReply_reasonCode',
+            'orderPage_environment', 'card_expirationMonth', 'merchantID',
+            'orderNumber_publicSignature', 'requestID', 'orderNumber',
+            'ccAuthReply_authorizedDateTime', 'card_cardType', 'ccAuthReply_avsCode'
+        ]
+
+        # Add the list of signed fields
+        resp_params['signedFields'] = ",".join(signed_fields)
+
+        # Calculate the fields signature
+        signed_fields_sig = processor_hash(resp_params['signedFields'])
+
+        # Calculate the public signature
+        hash_val = ",".join([
+            "{0}={1}".format(key, resp_params[key])
+            for key in signed_fields
+        ]) + ",signedFieldsPublicSignature={0}".format(signed_fields_sig)
+
+        resp_params['signedDataPublicSignature'] = processor_hash(hash_val)
+
+        return resp_params
+
+    def _payment_page_response(self, post_params, callback_url):
+        """
+        Render the payment page to a response.  This is an HTML form
+        that triggers a POST request to `callback_url`.
+
+        The POST params are described in the CyberSource documentation:
+        http://apps.cybersource.com/library/documentation/dev_guides/HOP_UG/html/wwhelp/wwhimpl/js/html/wwhelp.htm
+
+        To figure out the POST params to send to the callback,
+        we either:
+
+        1) Use fake static data (e.g. always send user name "John Doe")
+        2) Use the same info we received (e.g. send the same `course_id` and `amount`)
+        3) Dynamically calculate signatures using a shared secret
+        """
+
+        # Build the context dict used to render the HTML form,
+        # filling in values for the hidden input fields.
+        # These will be sent in the POST request to the callback URL.
+        context_dict = {
+
+            # URL to send the POST request to
+            "callback_url": callback_url,
+
+            # POST params embedded in the HTML form
+            'post_params': self.response_post_params(post_params)
+        }
+
+        return render_to_response('shoppingcart/test/fake_payment_page.html', context_dict)

lms/djangoapps/shoppingcart/tests/test_payment_fake.py

+"""
+Tests for the fake payment page used in acceptance tests.
+"""
+
+from django.test import TestCase
+from shoppingcart.processors.CyberSource import sign, verify_signatures, \
+    CCProcessorSignatureException
+from shoppingcart.tests.payment_fake import PaymentFakeView
+from collections import OrderedDict
+
+
+class PaymentFakeViewTest(TestCase):
+    """
+    Test that the fake payment view interacts
+    correctly with the shopping cart.
+    """
+
+    CLIENT_POST_PARAMS = OrderedDict([
+        ('match', 'on'),
+        ('course_id', 'edx/999/2013_Spring'),
+        ('amount', '25.00'),
+        ('currency', 'usd'),
+        ('orderPage_transactionType', 'sale'),
+        ('orderNumber', '33'),
+        ('merchantID', 'edx'),
+        ('djch', '012345678912'),
+        ('orderPage_version', 2),
+        ('orderPage_serialNumber', '1234567890'),
+    ])
+
+    def setUp(self):
+        super(PaymentFakeViewTest, self).setUp()
+
+        # Reset the view state
+        PaymentFakeView.PAYMENT_STATUS_RESPONSE = "success"
+
+    def test_accepts_client_signatures(self):
+
+        # Generate shoppingcart signatures
+        post_params = sign(self.CLIENT_POST_PARAMS)
+
+        # Simulate a POST request from the payment workflow
+        # page to the fake payment page.
+        resp = self.client.post(
+            '/shoppingcart/payment_fake', dict(post_params)
+        )
+
+        # Expect that the response was successful
+        self.assertEqual(resp.status_code, 200)
+
+        # Expect that we were served the payment page
+        # (not the error page)
+        self.assertIn("Payment Form", resp.content)
+
+    def test_rejects_invalid_signature(self):
+
+        # Generate shoppingcart signatures
+        post_params = sign(self.CLIENT_POST_PARAMS)
+
+        # Tamper with the signature
+        post_params['orderPage_signaturePublic'] = "invalid"
+
+        # Simulate a POST request from the payment workflow
+        # page to the fake payment page.
+        resp = self.client.post(
+            '/shoppingcart/payment_fake', dict(post_params)
+        )
+
+        # Expect that we got an error
+        self.assertIn("Error", resp.content)
+
+    def test_sends_valid_signature(self):
+
+        # Generate shoppingcart signatures
+        post_params = sign(self.CLIENT_POST_PARAMS)
+
+        # Get the POST params that the view would send back to us
+        resp_params = PaymentFakeView.response_post_params(post_params)
+
+        # Check that the client accepts these
+        try:
+            verify_signatures(resp_params)
+
+        except CCProcessorSignatureException:
+            self.fail("Client rejected signatures.")
+
+    def test_set_payment_status(self):
+
+        # Generate shoppingcart signatures
+        post_params = sign(self.CLIENT_POST_PARAMS)
+
+        # Configure the view to fail payments
+        resp = self.client.put(
+            '/shoppingcart/payment_fake',
+            data="failure", content_type='text/plain'
+        )
+        self.assertEqual(resp.status_code, 200)
+
+        # Check that the decision is "REJECT"
+        resp_params = PaymentFakeView.response_post_params(post_params)
+        self.assertEqual(resp_params.get('decision'), 'REJECT')
+
+        # Configure the view to accept payments
+        resp = self.client.put(
+            '/shoppingcart/payment_fake',
+            data="success", content_type='text/plain'
+        )
+        self.assertEqual(resp.status_code, 200)
+
+        # Check that the decision is "ACCEPT"
+        resp_params = PaymentFakeView.response_post_params(post_params)
+        self.assertEqual(resp_params.get('decision'), 'ACCEPT')

lms/djangoapps/shoppingcart/urls.py

@@ -13,3 +13,10 @@ if settings.MITX_FEATURES['ENABLE_SHOPPING_CART']:
         url(r'^remove_item/$', 'remove_item'),
         url(r'^add/course/(?P<course_id>[^/]+/[^/]+/[^/]+)/$', 'add_course_to_cart', name='add_course_to_cart'),
     )
+
+if settings.MITX_FEATURES.get('ENABLE_PAYMENT_FAKE'):
+    from shoppingcart.tests.payment_fake import PaymentFakeView
+    urlpatterns += patterns(
+        'shoppingcart.tests.payment_fake',
+        url(r'^payment_fake', PaymentFakeView.as_view())
+    )

lms/envs/acceptance.py

@@ -19,6 +19,7 @@ import logging
 logging.disable(logging.ERROR)
 import os
 from random import choice, randint
+import string
 
 
 def seed():
@@ -83,6 +84,23 @@ MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
 # Use the auto_auth workflow for creating users and logging them in
 MITX_FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] = True
 
+# Enable fake payment processing page
+MITX_FEATURES['ENABLE_PAYMENT_FAKE'] = True
+
+# Configure the payment processor to use the fake processing page
+# Since both the fake payment page and the shoppingcart app are using
+# the same settings, we can generate this randomly and guarantee
+# that they are using the same secret.
+RANDOM_SHARED_SECRET = ''.join(
+    choice(string.letters + string.digits + string.punctuation)
+    for x in range(250)
+)
+
+CC_PROCESSOR['CyberSource']['SHARED_SECRET'] = RANDOM_SHARED_SECRET
+CC_PROCESSOR['CyberSource']['MERCHANT_ID'] = "edx"
+CC_PROCESSOR['CyberSource']['SERIAL_NUMBER'] = "0123456789012345678901"
+CC_PROCESSOR['CyberSource']['PURCHASE_ENDPOINT'] = "/shoppingcart/payment_fake"
+
 # HACK
 # Setting this flag to false causes imports to not load correctly in the lettuce python files
 # We do not yet understand why this occurs. Setting this to true is a stopgap measure

lms/envs/test.py

@@ -155,6 +155,26 @@ OPENID_UPDATE_DETAILS_FROM_SREG = True
 OPENID_USE_AS_ADMIN_LOGIN = False
 OPENID_PROVIDER_TRUSTED_ROOTS = ['*']
 
+###################### Payment ##############################3
+# Enable fake payment processing page
+MITX_FEATURES['ENABLE_PAYMENT_FAKE'] = True
+
+# Configure the payment processor to use the fake processing page
+# Since both the fake payment page and the shoppingcart app are using
+# the same settings, we can generate this randomly and guarantee
+# that they are using the same secret.
+from random import choice
+import string
+RANDOM_SHARED_SECRET = ''.join(
+    choice(string.letters + string.digits + string.punctuation)
+    for x in range(250)
+)
+
+CC_PROCESSOR['CyberSource']['SHARED_SECRET'] = RANDOM_SHARED_SECRET
+CC_PROCESSOR['CyberSource']['MERCHANT_ID'] = "edx"
+CC_PROCESSOR['CyberSource']['SERIAL_NUMBER'] = "0123456789012345678901"
+CC_PROCESSOR['CyberSource']['PURCHASE_ENDPOINT'] = "/shoppingcart/payment_fake"
+
 ################################# CELERY ######################################
 
 CELERY_ALWAYS_EAGER = True

lms/templates/shoppingcart/test/fake_payment_error.html

+<html>
+    <head>
+        <title>Payment Error</title>
+    </head>
+    <body>
+        <p>An error occurred while you submitted your order.
+        If you are trying to make a purchase, please contact the merchant.</p>
+    </body>
+</html>

lms/templates/shoppingcart/test/fake_payment_page.html

+<html>
+<head><title>Payment Form</title></head>
+<body>
+    <p>Payment page</p>
+    <form name="input" action="${callback_url}" method="post">
+        % for name, value in post_params.items():
+        <input type="hidden" name="${name}" value="${value}">
+        % endfor
+        <input type="submit" value="Submit">
+    </form>
+</body>
+</html>