def test_capture_should_return_processor_transaction_declined(self):
     auth = Processor.authorize(self.pm.payment_method_token, 100.00)
     capture = auth.capture(100.02)
     self.assertFalse(capture.success)
     err = {'context': 'processor.transaction', 'key': 'declined', 'subclass': 'error'}
     self.assertIn(err, capture.error_messages)
     self.assertIn('The card was declined.', capture.errors['processor.transaction'])

 def test_capture_should_return_input_amount_invalid(self):
     auth = Processor.authorize(self.pm.payment_method_token, 100.00)
     capture = auth.capture(100.10)
     self.assertFalse(capture.success)
     err = {'context': 'input.amount', 'key': 'invalid', 'subclass': 'error'}
     self.assertIn(err, capture.error_messages)
     self.assertIn('The transaction amount was invalid.', capture.errors['input.amount'])

 def test_cvv_should_return_processor_cvv_result_code_N(self):
     token = test_helper.default_payment_method({'cvv':'222'}).payment_method_token
     purchase = Processor.purchase(token,
                                   1.00,
                                   billing_reference=self.rand)
     self.assertTrue(purchase.success)
     self.assertEqual(purchase.processor_response['cvv_result_code'], 'N')

def authorize(participant_id, pmt):
    """Given two unicodes, return a dict.

    This function attempts to authorize the credit card details referenced by
    pmt. If the attempt succeeds we cancel the transaction. If it fails we log
    the failure. Even for failure we keep the payment_method_token, we don't
    reset it to None/NULL. It's useful for loading the previous (bad) credit
    card info from Samurai in order to prepopulate the form.

    """
    typecheck(pmt, unicode, participant_id, unicode)
    transaction = Processor.authorize(pmt, '1.00', custom=participant_id)
    if transaction.errors:
        last_bill_result = json.dumps(transaction.errors)
        out = dict(transaction.errors)
    else:
        transaction.reverse()
        last_bill_result = ''
        out = {}
        
    STANDING = """\

    UPDATE participants
       SET payment_method_token=%s
         , last_bill_result=%s 
     WHERE id=%s

    """
    db.execute(STANDING, (pmt, last_bill_result, participant_id))
    return out

 def test_authorize_should_return_processor_avs_result_code_Y(self):
     token = test_helper.default_payment_method({'address_1':'1000 1st Av',
                                                 'address_2':'',
                                                 'zip':'10101'}).payment_method_token
     purchase = Processor.authorize(token,
                                   1.00,
                                   billing_reference=self.rand)
     self.assertTrue(purchase.success)
     self.assertEqual(purchase.processor_response['avs_result_code'], 'Y')

 def test_purchase_should_return_processor_transaction_declined(self):
     token = self.pm.payment_method_token
     purchase = Processor.purchase(token,
                                   1.02,
                                   billing_reference=self.rand)
     self.assertFalse(purchase.success)
     err = {'context': 'processor.transaction', 'key': 'declined', 'subclass': 'error'}
     self.assertIn(err, purchase.error_messages)
     self.assertIn('The card was declined.' , purchase.errors['processor.transaction'])

 def test_purchase_should_return_input_amount_invalid(self):
     token = self.pm.payment_method_token
     purchase = Processor.purchase(token,
                                   1.10,
                                   billing_reference=self.rand)
     self.assertFalse(purchase.success)
     err = {'context': 'input.amount', 'key': 'invalid', 'subclass': 'error'}
     self.assertIn(err, purchase.error_messages)
     self.assertIn('The transaction amount was invalid.', purchase.errors['input.amount'])

 def test_should_return_processor_avs_result_code_N(self):
     token = test_helper.default_payment_method({'address_1':'123 Main St',
                                                'address_2':'',
                                                'zip':'60610'}).payment_method_token
     purchase = Processor.purchase(token,
                                   1.00,
                                   billing_reference=self.rand)
     self.assertTrue(purchase.success)
     self.assertEqual(purchase.processor_response['avs_result_code'], 'N')

 def authorize(self, money, credit_card, options=None):
     if not self.validate_card(credit_card):
         raise InvalidCard("Invalid Card")
     try:
         from samurai.payment_method import PaymentMethod
         from samurai.processor import Processor
         pm = PaymentMethod.create(credit_card.number, credit_card.verification_value, credit_card.month, credit_card.year)
         payment_method_token = pm.payment_method_token
         response = Processor.authorize(payment_method_token, money)
     except Exception, error:
         return {'status': 'FAILURE', 'response': error}

def purchase(request):
    token = request.GET.get('payment_method_token', None)
    trans = Processor.purchase(token, 10)
    if trans.errors:
        errors = parse_error(trans.errors)
        for err in errors:
            messages.error(request, err, fail_silently=True)
        return redirect('/transparent_redirect/payment_form')
    else:
        messages.success(request, 'Purchase Successful.', fail_silently=True)
        return render_to_response('/transparent_redirect/receipt.html')

def purchase(request):
    if request.method == 'POST':
        token = request.POST.get('payment_method_token', None)
        trans = Processor.purchase(token, 10)
        if trans.errors:
            success=False
        else:
            success=True
        return_data = simplejson.dumps({'transaction':{'success':success}})
        return HttpResponse(return_data)
    else:
        return redirect('/samurai_js/payment_form')

 def auth(self, amount, credit_card=None, billing_info=None, shipping_info=None):
     # set up the card for charging, obviously
     card_token = self.charge_setup(credit_card, billing_info)
     # start the timer
     start = time.time()
     # send it over for processing
     response = Processor.authorize(card_token, amount)
     # measure time
     end = time.time() # done timing it
     response_time = '%0.2f' % (end-start)
     # return parsed response
     return self.parse(response, response_time)

 def authorize(self, money, credit_card, options=None):
     payment_method_token = credit_card
     if isinstance(credit_card, CreditCard):
         if not self.validate_card(credit_card):
             raise InvalidCard("Invalid Card")
         pm = PaymentMethod.create(credit_card.number, credit_card.verification_value, 
                                   credit_card.month, credit_card.year)
         payment_method_token = pm.payment_method_token
     response = Processor.authorize(payment_method_token, money)
     if response.errors:
         return {'status': 'FAILURE', 'response': response}
     return {'status': 'SUCCESS', 'response': response}

 def purchase(self, money, credit_card):
     # Cases where token is directly sent for e.g. from Samurai.js
     payment_method_token = credit_card
     if isinstance(credit_card, CreditCard):
         if not self.validate_card(credit_card):
             raise InvalidCard("Invalid Card")
         pm = PaymentMethod.create(credit_card.number, credit_card.verification_value,
                                   credit_card.month, credit_card.year)
         payment_method_token = pm.payment_method_token
     response = Processor.purchase(payment_method_token, money)
     if response.errors:
         return {'status': 'FAILURE', 'response': response}
     return {'status': 'SUCCESS', 'response': response}

 def test_purchase_should_be_successful(self):
     options = {'description':'description',
                'descriptor_name':'descriptor_name',
                'descriptor_phone':'descriptor_phone',
                'custom':'custom',
                'billing_reference':'ABC123%s' % self.rand,
                'customer_reference':'Customer (123)'}
     token = self.pm.payment_method_token
     purchase = Processor.purchase(token, 10.0, None, **options)
     self.assertTrue(purchase.success)
     self.assertEquals(purchase.error_messages, [])
     self.assertEqual(purchase.description, 'description')
     self.assertEqual(purchase.descriptor_name, 'descriptor_name')
     self.assertEqual(purchase.descriptor_phone, 'descriptor_phone')
     self.assertEqual(purchase.custom, 'custom')
     self.assertEqual(purchase.billing_reference, 'ABC123%s' % self.rand)
     self.assertEqual(purchase.customer_reference, 'Customer (123)')

 def test_purchase_should_return_invalid_sandbox_card_error(self):
     data = {
         'custom' : '',
         'first_name' : '',
         'last_name' : '',
         'address_1' : '',
         'address_2' : '',
         'city' : '',
         'state' : '',
         'zip' : '10101',
         'card_number' : '5256486068715680',
         'cvv' : '111',
         'expiry_month' : '05',
         'expiry_year' : '2014',
       }
     token = test_helper.default_payment_method(data).payment_method_token
     purchase = Processor.purchase(token, 1.00)
     self.assertIn({'context': 'system.general', 'key': 'default', 'subclass': 'error', 'text': 'Invalid Sandbox Card Number. For more information, see: https://samurai.feefighters.com/developers/sandbox'}, purchase.error_messages)

 def test_purchase_should_return_payment_method_errors_on_blank_pm(self):
     data = {
         'custom' : '',
         'first_name' : '',
         'last_name' : '',
         'address_1' : '',
         'address_2' : '',
         'city' : '',
         'state' : '',
         'zip' : '',
         'card_number' : '',
         'cvv' : '',
         'expiry_month' : '05',
         'expiry_year' : '2014',
       }
     token = test_helper.default_payment_method(data).payment_method_token
     purchase = Processor.purchase(token, 1.00)
     self.assertFalse(purchase.success)
     self.assertIn({'context': 'input.card_number', 'key': 'not_numeric', 'subclass': 'error'}, purchase.error_messages)
     self.assertIn({'context': 'input.card_number', 'key': 'too_short', 'subclass': 'error'}, purchase.error_messages)
     self.assertIn({'context': 'input.card_number', 'key': 'is_blank', 'subclass': 'error'}, purchase.error_messages)

 def setUp(self):
     self.pm = test_helper.default_payment_method()
     self.rand = randint(100, 999)
     self.auth = Processor.authorize(self.pm.payment_method_token, 100.0)
     self.purchase = Processor.purchase(self.pm.payment_method_token, 100.0)

 def test_authorize_failure(self):
     token = self.pm.payment_method_token
     trans = Processor.authorize(token, 10.02)
     errors = [{'context': 'processor.transaction', 'key': 'declined', 'subclass': 'error'}]
     self.assertEquals(trans.errors, errors)

 def test_purchase(self):
     token = self.pm.payment_method_token
     trans = Processor.purchase(token, 10.0)
     self.assertTrue(trans.success)
     self.assertEquals(trans.errors, [])