def test_signed_app_response(self, fake_req):
app_payment = self.payload()
# Ensure that the JWT sent to the app for payment notification
# includes the same payment data that the app originally sent.
def is_valid(payload):
data = jwt.decode(payload, self.inapp_config.get_private_key(),
verify=True)
eq_(data['iss'], settings.INAPP_MARKET_ID)
eq_(data['aud'], self.inapp_config.public_key)
eq_(data['typ'], 'mozilla/payments/pay/postback/v1')
eq_(data['request']['price'], app_payment['request']['price'])
eq_(data['request']['currency'],
app_payment['request']['currency'])
eq_(data['request']['name'], app_payment['request']['name'])
eq_(data['request']['description'],
app_payment['request']['description'])
eq_(data['request']['productdata'],
app_payment['request']['productdata'])
eq_(data['response']['transactionID'], self.contrib.pk)
assert data['iat'] <= calendar.timegm(time.gmtime()) + 60, (
'Expected iat to be about now')
assert data['exp'] > calendar.timegm(time.gmtime()) + 3500, (
'Expected exp to be about an hour from now')
return True
(fake_req.expects('post').with_args(arg.any(),
arg.passes_test(is_valid),
timeout=arg.any())
.has_attr(text='<not a valid response>'))
self.notify()
def test_pay_start_error(self, fetch_prod_im, cef):
self.inapp_config.addon.support_url = 'http://friendlyapp.org/support'
self.inapp_config.addon.support_email = '*****@*****.**'
self.inapp_config.addon.save()
def inspect_msg(msg):
assert 'RequestVerificationError' in msg, (
'CEF log should have exception message')
return True
cef.expects_call().with_args(arg.any(), 'unknown',
'inapp_pay_error',
arg.passes_test(inspect_msg),
severity=arg.any())
rp = self.start(req=self.request(app_secret='invalid'))
eq_(rp.status_code, 200)
doc = pq(rp.content)
eq_(doc('h3').text(), 'Payment Error')
self.assertContains(rp, 'mailto:[email protected]')
self.assertContains(rp, 'friendlyapp.org/support')
log = InappPayLog.objects.get()
eq_(log.action, InappPayLog._actions['EXCEPTION'])
eq_(log.app_public_key, self.inapp_config.public_key)
eq_(log.exception, InappPayLog._exceptions['RequestVerificationError'])
assert log.session_key, 'Unexpected session_key: %r' % log.session_key
assert not fetch_prod_im.delay.called, (
'product image not fetched on error')
def test_prepare_pay(self, api_post):
def good_data(da):
da = json.loads(da)
# TODO(Kumar) fix this when we have default currencies (bug 777747)
eq_(da['currency'], 'USD')
eq_(da['amount'], str(self.price.price))
eq_(da['app_name'], unicode(self.addon.name))
eq_(da['app_description'], unicode(self.addon.description))
eq_(da['postback_url'],
absolutify(reverse('bluevia.postback')))
eq_(da['chargeback_url'],
absolutify(reverse('bluevia.chargeback')))
pd = urlparse.parse_qs(da['product_data'])
assert 'contrib_uuid' in pd, 'Unexpected: %s' % pd
eq_(pd['addon_id'][0], str(self.addon.pk))
return True
# Sample of BlueVia JWT but not complete.
bluevia_jwt = {'typ': 'tu.com/payments/inapp/v1'}
(api_post.expects_call()
.with_args(arg.any(), data=arg.passes_test(good_data),
timeout=arg.any(), headers=arg.any())
.returns(Mock(text=json.dumps(bluevia_jwt),
status_code=200)))
data = self.post(self.prepare_pay)
cn = Contribution.objects.get(uuid=data['contrib_uuid'])
eq_(cn.type, amo.CONTRIB_PENDING)
eq_(cn.user, self.user)
eq_(cn.price_tier, self.price)
eq_(data['bluevia_jwt'], bluevia_jwt)
def test_signed_app_response(self, fake_req, slumber):
app_payment = self.payload()
self.set_secret_mock(slumber, 'f')
slumber.generic.product.get_object_or_404.return_value = {
'secret': 'f'}
# Ensure that the JWT sent to the app for payment notification
# includes the same payment data that the app originally sent.
def is_valid(payload):
data = jwt.decode(payload['notice'], 'f', # secret key
verify=True)
eq_(data['iss'], settings.NOTIFY_ISSUER)
eq_(data['typ'], TYP_POSTBACK)
eq_(data['request']['pricePoint'], 1)
eq_(data['request']['name'], app_payment['request']['name'])
eq_(data['request']['description'],
app_payment['request']['description'])
eq_(data['request']['productdata'],
app_payment['request']['productdata'])
eq_(data['request']['postbackURL'], 'http://foo.url/post')
eq_(data['request']['chargebackURL'], 'http://foo.url/charge')
eq_(data['response']['transactionID'], 'some:uuid')
assert data['iat'] <= gmtime() + 60, (
'Expected iat to be about now')
assert data['exp'] > gmtime() + 3500, (
'Expected exp to be about an hour from now')
return True
(fake_req.expects('post').with_args(arg.any(),
arg.passes_test(is_valid),
timeout=arg.any())
.returns_fake()
.has_attr(text='some:uuid')
.provides('raise_for_status'))
self.notify()
def test_signed_app_response(self, fake_req):
app_payment = self.payload()
# Ensure that the JWT sent to the app for payment notification
# includes the same payment data that the app originally sent.
def is_valid(payload):
data = jwt.decode(payload, self.iss.get_private_key(), verify=True)
eq_(data["iss"], settings.NOTIFY_ISSUER)
eq_(data["aud"], self.iss.issuer_key)
eq_(data["typ"], "mozilla/payments/pay/postback/v1")
eq_(data["request"]["pricePoint"], 1)
eq_(data["request"]["name"], app_payment["request"]["name"])
eq_(data["request"]["description"], app_payment["request"]["description"])
eq_(data["request"]["productdata"], app_payment["request"]["productdata"])
eq_(data["response"]["transactionID"], "some:uuid")
assert data["iat"] <= calendar.timegm(time.gmtime()) + 60, "Expected iat to be about now"
assert data["exp"] > calendar.timegm(time.gmtime()) + 3500, "Expected exp to be about an hour from now"
return True
(
fake_req.expects("post")
.with_args(arg.any(), arg.passes_test(is_valid), timeout=arg.any())
.returns_fake()
.has_attr(text="<not a valid response>")
.provides("raise_for_status")
)
self.notify()
def test_configurable_http(self, fake_req):
self.iss_update(is_https=False)
url = self.url(self.postback, protocol="http")
(fake_req.expects("post").with_args(url, arg.any(), timeout=arg.any()).returns_fake().is_a_stub())
self.notify()
notice = Notice.objects.get()
eq_(notice.last_error, "")
def test_configurable_http(self, urlopen):
self.inapp_config.update(is_https=False)
url = self.url(self.postback, protocol="http")
(urlopen.expects_call().with_args(url, arg.any(), timeout=arg.any()).returns_fake().is_a_stub())
self.notify()
notice = InappPayNotice.objects.get()
eq_(notice.last_error, "")
def test_signed_app_response(self, urlopen):
app_payment = self.payload()
# Ensure that the JWT sent to the app for payment notification
# includes the same payment data that the app originally sent.
def is_valid(payload):
data = jwt.decode(payload, self.inapp_config.private_key, verify=True)
eq_(data["iss"], settings.INAPP_MARKET_ID)
eq_(data["aud"], self.inapp_config.public_key)
eq_(data["typ"], "mozilla/payments/pay/postback/v1")
eq_(data["request"]["price"], app_payment["request"]["price"])
eq_(data["request"]["currency"], app_payment["request"]["currency"])
eq_(data["request"]["name"], app_payment["request"]["name"])
eq_(data["request"]["description"], app_payment["request"]["description"])
eq_(data["request"]["productdata"], app_payment["request"]["productdata"])
eq_(data["response"]["transactionID"], self.contrib.pk)
assert data["iat"] <= calendar.timegm(time.gmtime()) + 60, "Expected iat to be about now"
assert data["exp"] > calendar.timegm(time.gmtime()) + 3500, "Expected exp to be about an hour from now"
return True
(
urlopen.expects_call()
.with_args(arg.any(), arg.passes_test(is_valid), timeout=arg.any())
.returns_fake()
.expects("read")
.returns("<not a valid response>")
.expects("close")
)
self.notify()
def test_pay_start_error(self, fetch_prod_im, cef):
self.inapp_config.addon.support_url = 'http://friendlyapp.org/support'
self.inapp_config.addon.support_email = '*****@*****.**'
self.inapp_config.addon.save()
def inspect_msg(msg):
assert 'RequestVerificationError' in msg, (
'CEF log should have exception message')
return True
cef.expects_call().with_args(arg.any(),
'unknown',
'inapp_pay_error',
arg.passes_test(inspect_msg),
severity=arg.any())
rp = self.start(req=self.request(app_secret='invalid'))
eq_(rp.status_code, 200)
doc = pq(rp.content)
eq_(doc('h3').text(), 'Payment Error')
self.assertContains(rp, 'mailto:[email protected]')
self.assertContains(rp, 'friendlyapp.org/support')
log = InappPayLog.objects.get()
eq_(log.action, InappPayLog._actions['EXCEPTION'])
eq_(log.app_public_key, self.inapp_config.public_key)
eq_(log.exception, InappPayLog._exceptions['RequestVerificationError'])
assert log.session_key, 'Unexpected session_key: %r' % log.session_key
assert not fetch_prod_im.delay.called, (
'product image not fetched on error')
def test_invalid_contrib_uuid(self, cef):
cef.expects_call().with_args(arg.any(),
self.inapp_config.addon,
'inapp_pay_status',
arg.any(),
severity=arg.any())
res = self.client.get(self.complete_url, {'uuid': 'invalid-uuid'})
self.assertContains(res, 'Payment Error')
def test_adds_is_test_to_api_class_api_if_in_testing_mode(self):
api_class = fudge.Fake().expects_call().with_args(arg.any(), arg.any(),
delimiter=arg.any(), is_test=True)
backend = backends.AuthorizeNetBackend(testing=True)
with fudge.patched_context(backend, "api_class", api_class):
backend.get_api()
fudge.verify()
def test_configurable_http(self, fake_req):
self.inapp_config.update(is_https=False)
url = self.url(self.postback, protocol='http')
(fake_req.expects('post').with_args(
url, arg.any(), timeout=arg.any()).returns_fake().is_a_stub())
self.notify()
notice = InappPayNotice.objects.get()
eq_(notice.last_error, '')
def test_is_test_is_false_for_api_class_api_by_default(self):
api_class = fudge.Fake().expects_call().with_args(arg.any(), arg.any(),
delimiter=arg.any(), is_test=False)
backend = backends.AuthorizeNetBackend()
with fudge.patched_context(backend, "api_class", api_class):
backend.get_api()
fudge.verify()
def test_adds_is_test_to_recurring_api_class_api_if_in_testing_mode(self):
recurring_api_class = fudge.Fake().expects_call().with_args(
arg.any(), arg.any(), is_test=True)
backend = backends.AuthorizeNetBackend(testing=True)
with fudge.patched_context(backend, "recurring_api_class",
recurring_api_class):
backend.get_recurring_api()
fudge.verify()
def test_is_test_is_false_for_recurring_api_class_api_by_default(self):
recurring_api_class = fudge.Fake().expects_call().with_args(
arg.any(), arg.any(), is_test=False)
backend = backends.AuthorizeNetBackend()
with fudge.patched_context(backend, "recurring_api_class",
recurring_api_class):
backend.get_recurring_api()
fudge.verify()
def test_force_https(self, fake_req):
self.iss_update(is_https=False)
url = self.url(self.postback, protocol='https')
(fake_req.expects('post').with_args(url, arg.any(), timeout=arg.any())
.returns_fake()
.is_a_stub())
self.notify()
notice = Notice.objects.get()
eq_(notice.last_error, '')
def test_configurable_http(self, fake_req):
self.inapp_config.update(is_https=False)
url = self.url(self.postback, protocol='http')
(fake_req.expects('post').with_args(url, arg.any(), timeout=arg.any())
.returns_fake()
.is_a_stub())
self.notify()
notice = InappPayNotice.objects.get()
eq_(notice.last_error, '')
def test_mail_contains_text_for_claiming_via_url(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
self.bid1.ask_match_sent = timezone.now()
self.bid1.save()
mock_send_mail.expects_call().with_args(arg.any(),
arg.contains(self.bid1.url),
arg.any(), ['*****@*****.**'])
mommy.make(Bid, offer=100, user=user, ask=1000, url=self.url)
def test_post_key_to_api_uses_requests_json(self, request):
pa = mommy.make(PushApplication, vapid_key_status='valid')
request.expects_call().with_args(
'post',
arg.any(),
json={'public-key': pa.vapid_key},
timeout=arg.any()
).returns(
MESSAGES_API_POST_RESPONSE
)
pa.post_key_to_api()
def test_create(self, fetch):
recent = fetch.expects_call().with_args(self.recent_url,
deadline=arg.any())
recent.returns_fake().has_attr(status_code=200)
now = recent.next_call().with_args(self.now_url,
deadline=arg.any())
now.returns_fake().has_attr(status_code=200)
resp = self.client.post(reverse('playlists.send_track_to_live_site'), {
'id': self.track.key()
})
def test_create(self, fetch):
recent = fetch.expects_call().with_args(self.recent_url,
deadline=arg.any())
recent.returns_fake().has_attr(status_code=200)
now = recent.next_call().with_args(self.now_url,
deadline=arg.any())
now.returns_fake().has_attr(status_code=200)
resp = self.client.post(reverse('playlists.send_track_to_live_site'), {
'id': self.track.key()
})
def test_delete_key_from_messages_api_204(self, request):
pa = mommy.make(PushApplication, vapid_key_status='recording')
request.expects_call().with_args(
'delete',
arg.any(),
json=arg.any(),
timeout=arg.any()
).returns(
fudge.Fake().has_attr(status_code=204)
)
delete_key_from_messages_api(PushApplication, pa)
def test_post_key_to_api_uses_requests_json(self, request):
pa = mommy.make(PushApplication, vapid_key_status='valid')
request.expects_call().with_args(
'post',
arg.any(),
json={
'public-key': pa.vapid_key
},
timeout=arg.any()).returns(
fudge.Fake().has_attr(status_code=200).expects('json').returns(
self.fake_post_response_json))
pa.post_key_to_api()
def test_post_key_to_api_uses_requests_json(self, request):
pa = mommy.make(PushApplication, vapid_key_status='valid')
request.expects_call().with_args(
'post',
arg.any(),
json={'public-key': pa.vapid_key},
timeout=arg.any()
).returns(
fudge.Fake().has_attr(status_code=200).expects('json').returns(
self.fake_post_response_json
)
)
pa.post_key_to_api()
def test_delete_key_from_messages_api_404(self, request):
# TODO: Decide what to do with 404 responses to DELETE
# https://github.com/mozilla-services/push-dev-dashboard/issues/205#issuecomment-217182142
pa = mommy.make(PushApplication, vapid_key_status='recording')
request.expects_call().with_args(
'delete',
arg.any(),
json=arg.any(),
timeout=arg.any()
).returns(
fudge.Fake().has_attr(status_code=404)
)
with self.assertRaises(MessagesAPIError):
delete_key_from_messages_api(PushApplication, pa)
def test_only_send_mail_to_unsent_matching_askers(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
self.bid1.ask_match_sent = timezone.now()
self.bid1.save()
subject = "[codesy] There's $100 waiting for you!"
mock_send_mail.expects_call().with_args(subject, arg.any(), arg.any(),
['*****@*****.**'])
offer_bid = mommy.make(Bid,
offer=100,
user=user,
ask=1000,
url=self.url)
offer_bid.save()
def test_send_mail_to_matching_askers(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
bid1_subject = "[codesy] There's $50 waiting for you!"
bid2_subject = "[codesy] There's $100 waiting for you!"
mock_send_mail.expects_call().with_args(bid1_subject, arg.any(),
arg.any(), ['*****@*****.**'])
mock_send_mail.next_call().with_args(bid2_subject, arg.any(),
arg.any(), ['*****@*****.**'])
offer_bid = mommy.make(Bid,
offer=100,
user=user,
ask=1000,
url=self.url)
offer_bid.save()
def test_mail_contains_text_for_claiming_via_url(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
self.bid1.ask_match_sent = timezone.now()
self.bid1.save()
mock_send_mail.expects_call().with_args(
arg.any(),
arg.contains(self.bid1.url),
arg.any(),
['*****@*****.**']
)
mommy.make(
Bid, offer=100, user=user, ask=1000, url=self.url
)
def test_with_kwargs_with_object_that_is_never_equal_to_anything(self):
class NeverEqual(object):
def __eq__(self, other):
return False
obj = NeverEqual()
self.fake.expects('save').with_args(foo=arg.any())
self.fake.save(foo=obj) # this should pass but was failing prior to issue 9
def test_context_manager(fake):
fudge.patch_object(statsd.StatsClient, 'timing', mock_statsd_method)
k = kruxstatsd.StatsClient('js', env='prod')
fake.expects_call().with_args('prod.js.mytimer.%s' % (hostname, ),
arg.any(), 1)
with k.timer('mytimer'):
assert True
def test_postback(self, slumber, fake_req):
self.set_secret_mock(slumber, 'f')
payload = self.payload(typ=TYP_POSTBACK,
extra_req={'simulate': {
'result': 'postback'
}})
url = payload['request']['postbackURL']
def req_ok(req):
dd = jwt.decode(req['notice'], verify=False)
eq_(dd['request'], payload['request'])
eq_(dd['typ'], payload['typ'])
jwt.decode(req['notice'], 'f', verify=True)
return True
(fake_req.expects('post').with_args(
url, arg.passes_test(req_ok),
timeout=arg.any()).returns_fake().has_attr(
text=self.trans_uuid).expects('raise_for_status'))
self.notify(payload)
notice = Notice.objects.get()
assert notice.transaction_uuid, notice
eq_(notice.success, True)
eq_(notice.url, url)
eq_(notice.simulated, SIMULATED_POSTBACK)
def test_only_send_mail_to_unsent_matching_askers(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
self.bid1.ask_match_sent = datetime.now()
self.bid1.save()
mock_send_mail.expects_call().with_args(
self._add_url('[codesy] Your ask for 100 for {url} has been met'),
arg.any(),
arg.any(),
['*****@*****.**']
)
offer_bid = mommy.prepare(
Bid, offer=100, user=user, ask=1000, url=self.url
)
offer_bid.save()
def test_chargeback(self, slumber, fake_req):
self.set_secret_mock(slumber, 'f')
req = {'simulate': {'result': 'chargeback'}}
payload = self.payload(typ=TYP_CHARGEBACK,
extra_req=req)
url = payload['request']['chargebackURL']
def req_ok(req):
dd = jwt.decode(req['notice'], verify=False)
eq_(dd['request'], payload['request'])
eq_(dd['typ'], payload['typ'])
jwt.decode(req['notice'], 'f', verify=True)
return True
(fake_req.expects('post').with_args(url, arg.passes_test(req_ok),
timeout=arg.any())
.returns_fake()
.has_attr(text=self.trans_uuid)
.expects('raise_for_status'))
self.notify(payload)
notice = Notice.objects.get()
assert notice.transaction_uuid, notice
eq_(notice.success, True)
eq_(notice.url, url)
eq_(notice.simulated, SIMULATED_CHARGEBACK)
def test_with_kwargs_with_object_that_is_never_equal_to_anything(self):
class NeverEqual(object):
def __eq__(self, other):
return False
obj = NeverEqual()
self.fake.expects('save').with_args(foo=arg.any())
self.fake.save(foo=obj) # this should pass but was failing prior to issue 9
def test_reset(self, cef):
cfg = self.config(public_key='old-key',
private_key='old-secret')
def inspect_msg(msg):
assert 'old-key' in msg, 'CEF should log old key'
return True
cef.expects_call().with_args(arg.any(),
cfg.addon,
'inapp_reset',
arg.passes_test(inspect_msg),
severity=6)
res = self.client.post(self.get_url(cfg.pk))
self.assertRedirects(res, self.webapp.get_dev_url('in_app_config'))
old_cfg = InappConfig.objects.get(pk=cfg.pk)
eq_(old_cfg.status, amo.INAPP_STATUS_REVOKED)
inapp = InappConfig.objects.get(addon=self.webapp,
status=amo.INAPP_STATUS_ACTIVE)
eq_(inapp.chargeback_url, cfg.chargeback_url)
eq_(inapp.postback_url, cfg.postback_url)
assert inapp.public_key != cfg.public_key, (
'Unexpected: %s' % inapp.public_key)
pk = inapp.get_private_key()
assert pk != cfg.get_private_key, ('Unexpected: %s' % pk)
def test_context_manager(fake):
fudge.patch_object(statsd.StatsClient, 'timing', mock_statsd_method)
k = kruxstatsd.StatsClient('js', env='prod')
fake.expects_call().with_args(
'prod.js.mytimer.%s' % (hostname,), arg.any(), 1)
with k.timer('mytimer'):
assert True
def test_postback(self, fake_req):
(fake_req.expects('post').with_args(self.purchase_url,
self.signed_jwt,
timeout=arg.any())
.returns_fake()
.has_attr(text=str(self.contrib.pk))
.expects('raise_for_status'))
self.purchase_notify()
def test_only_send_mail_to_unsent_matching_askers(self, mock_send_mail):
user = mommy.make(settings.AUTH_USER_MODEL)
self.bid1.ask_match_sent = timezone.now()
self.bid1.save()
subject = "[codesy] There's $100 waiting for you!"
mock_send_mail.expects_call().with_args(
subject,
arg.any(),
arg.any(),
['*****@*****.**']
)
offer_bid = mommy.make(
Bid, offer=100, user=user, ask=1000, url=self.url
)
offer_bid.save()
def test_absolute_url(self, fake_req):
url = 'http://mycdn-somewhere.com/media/my.jpg'
(fake_req.expects('get')
.with_args(url, timeout=arg.any())
.returns_fake()
.has_attr(raw=self.open_img())
.expects('raise_for_status'))
self.fetch(url=url)
def test_postback(self, fake_req):
(fake_req.expects('post').with_args(self.purchase_url,
self.signed_jwt,
timeout=arg.any())
.returns_fake()
.has_attr(text=str(self.contrib.pk))
.expects('raise_for_status'))
self.purchase_notify()
def test_paykey_pre_approval_empty(self, _call, check_purchase):
check_purchase.return_value = 'COMPLETED'
PreApprovalUser.objects.create(user=self.user, paypal_key='')
r = lambda s: 'receiverList.receiver(0).email' in s
(_call.expects_call()
.with_matching_args(arg.any(), arg.passes_test(r))
.returns({'payKey': 'some-pay-key',
'paymentExecStatus': 'COMPLETED'}))
self.client.post_ajax(self.purchase_url)
def test_updates_config(self):
# first assert signatures of the functions we are going to mock did not change.
assert_spec(self.sqlite_db.set_config_value, ['self', 'group', 'key', 'value'])
self.sqlite_db.set_config_value = fudge.Fake('set_config_value')\
.expects_call()\
.with_args('activity', 'change', arg.any())
self.sqlite_db._mark_update()
fudge.verify()
def test_process_mp3(self, store, album_art):
store.expects_call().with_args(arg.any(), self.session_key)
album_art.expects('delay')
tasks.process_file('*****@*****.**', self.sample_path, self.session_key)
tr = Track.objects.get()
eq_(tr.email.email, '*****@*****.**')
eq_(tr.artist, 'Gescom')
eq_(tr.album, 'Minidisc')
eq_(tr.track, 'Horse')
eq_(tr.session.pk, self.session_key)
eq_(tr.track_num, 53)
def test_fetch_ok(self, fake_req):
url = '/media/my.jpg'
(fake_req.expects('get').with_args(
self.url(url), timeout=arg.any()).returns_fake().has_attr(
raw=self.open_img()).expects('raise_for_status'))
self.fetch(url=url)
prod = InappImage.objects.get()
assert os.path.exists(prod.path()), 'Image not created'
eq_(prod.valid, True)
eq_(prod.processed, True)
eq_(prod.config.pk, self.inapp_config.pk)
def test_fetch_ok(self, urlopen):
url = '/media/my.jpg'
(urlopen.expects_call()
.with_args(self.url(url), timeout=arg.any())
.returns(self.open_img()))
self.fetch(url=url)
prod = InappImage.objects.get()
assert os.path.exists(prod.path()), 'Image not created'
eq_(prod.valid, True)
eq_(prod.processed, True)
eq_(prod.config.pk, self.inapp_config.pk)
def test_fetch_ok(self, fake_req):
url = 'http://site/media/my.jpg'
ext_size = 512
size = 64
(fake_req.expects('get').with_args(
url,
timeout=arg.any()).returns_fake().expects('iter_content').returns(
self.open_img()).expects('raise_for_status'))
self.fetch(url, ext_size, size)
prod = ProductIcon.objects.get()
eq_(prod.ext_size, ext_size)
eq_(prod.size, size)
assert public_storage.exists(prod.storage_path()), 'Image not created'
def test_preauth_ok(self, check_purchase, get_paykey, payment_notify):
payload = self.payload()
get_paykey.expects_call().returns(['some-pay-key', 'COMPLETED'])
check_purchase.expects_call().returns('COMPLETED')
payment_notify.expects('delay').with_args(arg.any()) # pay ID to-be
req = self.request(payload=json.dumps(payload))
self.client.post(reverse('inapp_pay.pay'), dict(req=req))
logs = InappPayLog.objects.all().order_by('created')
eq_(logs[0].action, InappPayLog._actions['PAY'])
eq_(logs[1].action, InappPayLog._actions['PAY_COMPLETE'])
def test_signed_app_response(self, fake_req, slumber):
app_payment = self.payload()
self.set_secret_mock(slumber, 'f')
slumber.generic.product.get_object_or_404.return_value = {
'secret': 'f'
}
# Ensure that the JWT sent to the app for payment notification
# includes the same payment data that the app originally sent.
def is_valid(payload):
data = jwt.decode(
payload['notice'],
'f', # secret key
verify=True,
audience=self.payment_issuer)
eq_(data['iss'], settings.NOTIFY_ISSUER)
eq_(data['typ'], TYP_POSTBACK)
eq_(data['request']['pricePoint'], 1)
eq_(data['request']['name'], app_payment['request']['name'])
eq_(data['request']['description'],
app_payment['request']['description'])
eq_(data['request']['productdata'],
app_payment['request']['productdata'])
eq_(data['request']['postbackURL'], 'http://foo.url/post')
eq_(data['request']['chargebackURL'], 'http://foo.url/charge')
eq_(data['response']['transactionID'], 'some:uuid')
assert data['iat'] <= gmtime() + 60, (
'Expected iat to be about now')
assert data['exp'] > gmtime() + 3500, (
'Expected exp to be about an hour from now')
return True
(fake_req.expects('post').with_args(
arg.any(), arg.passes_test(is_valid),
timeout=arg.any()).returns_fake().has_attr(
text='some:uuid').provides('raise_for_status'))
self.notify(payload=app_payment)
def test_api_instantiates_api_class_with_configured_settings(self):
random_login = "******" % random.randint(100, 200)
random_key = "some random key %d" % random.randint(100, 200)
random_return = "some random return %d" % random.randint(100, 200)
settings = fudge.Fake()
settings.has_attr(AUTHORIZE={
"LOGIN": random_login,
"KEY": random_key,
})
api_class = fudge.Fake()
# Note that delimiter is included here because authorize's code
# can't even keep track of what deliminter it wants to use!
(api_class.expects_call().with_args(
random_login, random_key, delimiter=arg.any(),
is_test=arg.any()).returns(random_return))
fudge.clear_calls()
backend = backends.AuthorizeNetBackend(api_class=api_class,
settings=settings)
result = backend.get_api()
self.assertEqual(result, random_return)
fudge.verify()
def base_setup(self, option_overrides):
# Create a fake VirtstrapConfig
config = fudge.Fake()
config.provides('from_file').returns(config)
self.config = (config.provides('process_section').with_args(
'project_name', arg.any()).returns('projdir'))
# Patch VirtstrapConfig
self.config_patch = patch_object('virtstrap.project',
'VirtstrapConfig', config)
base_parser = create_base_parser()
options = base_parser.parse_args(args=[])
# Add any overrides
for name, override in option_overrides.iteritems():
setattr(options, name, override)
self._options = options
self._project = None
def test_run_server_should_pass_xheaders_to_correct_method(
self, settings, IOLoop, Application):
settings.has_attr(ROOT_URLS='tests.core.test_server')
PORT = 1234
XHEADERS = True
# Just to prevent the test from hanging
IOLoop.is_a_stub()
(Application.is_callable().with_args(
arg.any(), cookie_secret=None,
debug=False).returns_fake().expects('listen').with_args(
PORT, xheaders=XHEADERS))
torneira_server = server.TorneiraServer(PORT, '/my_media/', XHEADERS)
torneira_server.run()
def test_fires_donation_complete_on_successful_charge(self):
donation, form = self.random_donation_and_form
result = {
"status": True,
"random": random.randint(100, 200),
}
backend = backends.Backend()
signal = (fudge.Fake().expects_call().with_args(sender=backend,
donation=donation,
signal=arg.any(),
form=form,
result=result))
signals.successful_purchase.connect(signal)
backend.send_successful_purchase(donation, form, result)
fudge.verify()
signals.successful_purchase.disconnect(signal)
def test_password_reset(self, fake_send):
(fake_send.expects_call().with_args(
'*****@*****.**', 'forgot', 'Reset Your Draughtcraft Password', {
'name': 'Ryan',
'code': arg.any()
}))
model.User(first_name=u'Ryan', email=u'*****@*****.**')
model.commit()
response = self.post('/forgot/',
params={'email': model.User.get(1).email})
assert model.PasswordResetRequest.query.count() == 1
assert response.status_int == 302
assert response.headers['Location'].endswith('/login')
def test_chargeback_reason(self, slumber, fake_req):
self.set_secret_mock(slumber, 'f')
reason = 'something'
req = {'simulate': {'result': 'chargeback', 'reason': reason}}
payload = self.payload(typ=TYP_CHARGEBACK, extra_req=req)
url = payload['request']['chargebackURL']
def req_ok(req):
dd = jwt.decode(req['notice'], verify=False)
eq_(dd['request'], payload['request'])
eq_(dd['response']['reason'], reason)
return True
(fake_req.expects('post').with_args(
url, arg.passes_test(req_ok),
timeout=arg.any()).returns_fake().has_attr(
text=self.trans_uuid).expects('raise_for_status'))
self.notify(payload)
def test_get_recurring_api_instantiates_with_configured_settings(self):
random_login = "******" % random.randint(100, 200)
random_key = "some random key %d" % random.randint(100, 200)
random_return = "some random return %d" % random.randint(100, 200)
settings = fudge.Fake().has_attr(AUTHORIZE={
"LOGIN": random_login,
"KEY": random_key,
})
recurring_api_class = (fudge.Fake().expects_call().with_args(
random_login, random_key,
is_test=arg.any()).returns(random_return))
fudge.clear_calls()
backend = backends.AuthorizeNetBackend(
settings=settings, recurring_api_class=recurring_api_class)
result = backend.get_recurring_api()
self.assertEqual(result, random_return)
fudge.verify()
