def test_order_find_coupons(self):
# We need to see results of order_process immediately in this test
self.cpolicy.SetProbability(1.0)
# Create two orders and process successful payment
ct = model.CouponType('test', 300.0, "Test flight")
order1 = model.order_create('1', ct, test=True)
model.order_process(order1.order_id, '*****@*****.**', 100.0, 'EUR')
order2 = model.order_create('2', ct, test=True)
model.order_process(order2.order_id, '*****@*****.**', 100.0, 'EUR')
coupons = model.order_find_coupons(order1.order_id)
self.assertEqual(len(coupons), 1)
self.assertEqual(coupons[0].order.order_id, order1.order_id)
def test_order_process(self):
# Create sample order
ct = model.CouponType('test', 300.0, "Test flight")
order = model.order_create('1', ct, test=True)
# Process successful payment
order, coupons = model.order_process(order.order_id,
'*****@*****.**', 100.0, 'EUR',
payer_name='Andrey',
payer_surname='Lebedev',
payment_provider='dnb')
self.assertEqual(order.status, model.Order.ST_PAID)
self.assertEqual(order.payer_name, 'Andrey')
self.assertEqual(order.payer_surname, 'Lebedev')
self.assertEqual(order.payer_email, u'*****@*****.**')
self.assertIsNotNone(order.payment_time)
self.assertEqual(order.paid_amount, 100.0)
self.assertEqual(order.paid_currency, 'EUR')
# Check created coupon
self.assertEqual(len(coupons), 1)
coupon = coupons[0]
self.assertIsNotNone(coupon.order)
self.assertIs(coupon.order, order)
self.assertEqual(coupon.status, model.Coupon.ST_ACTIVE)
self.assertIsNone(coupon.use_time)
cid = coupon.coupon_id
self.assertEqual(len(cid), 9)
# Make sure coupon is in database
self.assertEqual(model.coupon_get(cid).key(), coupon.key())
def test_coupon_search(self):
self.cpolicy.SetProbability(1.0)
ct = model.CouponType('test', 300.0, "Test flight")
with freeze_time(datetime.datetime(2013, 2, 16)):
order1 = model.order_create('1', ct, test=True)
model.order_process(order1.order_id, '*****@*****.**', 100.0, 'EUR')
with freeze_time(datetime.datetime(2013, 12, 31)):
order2 = model.order_create('2', ct, test=True)
o, coupons = model.order_process(order2.order_id, '*****@*****.**',
100.0, 'EUR')
model.coupon_use(coupons[0].coupon_id)
with freeze_time(datetime.datetime(2014, 1, 11)):
order2 = model.order_create('3', ct, test=True)
model.order_process(order2.order_id, '*****@*****.**', 100.0, 'EUR')
def test_order_create(self):
ct = model.CouponType('test', 300.0, "Test flight")
order = model.order_create(model.order_gen_id(), ct, test=True)
self.assertEqual(order.coupon_type, 'test')
self.assertEqual(order.price, 300.0)
self.assertEqual(order.status == model.Order.ST_PENDING, True)
self.assertEqual(order.currency, 'EUR')
self.assertIsNotNone(order.create_time)
def post(self, name):
ct = model.get_coupon_type(name)
assert ct.in_stock, "Cannot order this item"
order_id = model.order_gen_id()
order = model.order_create(order_id, ct, test=self.app.config['debug'])
data = self.prepare_webtopay_request(order, ct)
logging.info('Starting payment transaction for %s' % data)
url = webtopay.get_redirect_to_payment_url(data)
webapp2.redirect(url, abort=True)
def test_order_cancel(self):
# Create order
ct = model.CouponType('test', 300.0, "Test flight")
order = model.order_create(model.order_gen_id(), ct, test=True)
# Cancelling order changes its status
cancelled = model.order_cancel(order.key().name())
self.assertEqual(cancelled.status, model.Order.ST_CANCELLED)
# You cannot cancel already cancelled order
with self.assertRaisesRegexp(ValueError,
r'Cannot cancel non-pending order .*'):
model.order_cancel(order.key().name())
def test_admin_check(self):
app = create_testapp()
self.cpolicy.SetProbability(1.0)
ct = model.get_coupon_type("plane_long")
order = model.order_create("1", ct)
coupons = model.coupon_create(order)
cid = coupons[0].coupon_id
resp = app.get("/admin/check/%s" % cid)
self.assertEqual(resp.status, "200 OK")
self.assertIn("Kvietimas galioja.", resp)
def test_qr(self):
app = create_testapp()
ct = model.get_coupon_type("plane_long")
order = model.order_create("1", ct)
coupons = model.coupon_create(order)
self.assertEquals(len(coupons), 1)
cid = coupons[0].coupon_id
resp = app.get("/qr/%s" % cid)
self.assertEqual(resp.status, "200 OK")
self.assertEqual(resp.headers['Content-Type'], 'image/png')
self.assertEqual(resp.body[:4], '\x89PNG')
def test_coupon(self):
# Make sure coupon page is generated with all registered coupon types
app = create_testapp()
for idx, ct in enumerate(model.coupon_types):
order = model.order_create(str(idx), ct)
coupons = model.coupon_create(order)
self.assertEquals(len(coupons), 1)
cid = coupons[0].coupon_id
resp = app.get('/coupon/%s' % cid)
self.assertIn(cid, resp)
def test_admin_check_use(self):
app = create_testapp()
self.cpolicy.SetProbability(1.0)
ct = model.get_coupon_type("plane_long")
order = model.order_create("1", ct)
coupons = model.coupon_create(order)
cid = coupons[0].coupon_id
resp = app.post("/admin/check/%s" % cid)
self.assertEqual(resp.status, "302 Moved Temporarily")
used = model.coupon_get(cid)
self.assertEqual(used.status, model.Coupon.ST_USED)
def test_accept(self):
# We need to see results of order_process immediately in this test
self.cpolicy.SetProbability(1.0)
ct = model.CouponType('test', 200.0, 'Test coupon')
order = model.order_create('1', ct)
with mock.patch('soaringcoupons.model.coupon_gen_id') as m:
m.return_value = '1001'
order, coupons = model.order_process(order.order_id,
'*****@*****.**', 200.0, 'LTL')
# load "accept" url
app = create_testapp()
resp = app.get('/accept/1')
self.assertIn('<a href="/coupon/1001"', resp)
def test_dashboard(self):
app = create_testapp()
self.cpolicy.SetProbability(1.0)
# Pre-generate some coupons
ct = model.get_coupon_type("plane_long")
order = model.order_create("1", ct)
model.coupon_create(order)
model.coupon_spawn(model.get_coupon_type("training"), 3,
"*****@*****.**", "test")
resp = app.get("/admin")
self.assertEqual(resp.status, "200 OK")
self.assertIn("Statistika", resp)
def test_coupon_unknown_type(self):
# Make sure we fail if we try to generate coupon for unknown type
app = create_testapp()
ct = model.CouponType('test', 200.0, 'Test coupon')
order = model.order_create("1", ct)
coupons = model.coupon_create(order)
self.assertEquals(len(coupons), 1)
cid = coupons[0].coupon_id
# Let's pretend coupon_type test is a registered type
with mock.patch('soaringcoupons.model.get_coupon_type') as m:
m.return_value = ct
with self.assertRaises(webtest.AppError):
app.get('/coupon/%s' % cid)
def test_order_process_twice(self):
# Create sample order
ct = model.CouponType('test', 300.0, "Test flight")
order = model.order_create('2', ct, test=True)
# Process successful payment
order, coupon = model.order_process(order.order_id,
'*****@*****.**', 100.0, 'EUR',
payer_name='Andrey',
payer_surname='Lebedev',
payment_provider='dnb')
# Attempt to process payment second time and expect the exception
with self.assertRaisesRegexp(ValueError,
r'Cannot process non-pending order .*'):
model.order_process(order.order_id, '*****@*****.**', 100.0, 'EUR')
def test_jsonify_coupon(self):
# Create sample order
ct = model.CouponType('test', 300.0, "Test flight")
# Process successful payment
with freeze_time(datetime.datetime(2012, 1, 4)):
order = model.order_create('1', ct, test=True)
order, coupons = model.order_process(order.order_id,
'*****@*****.**', 100.0, 'EUR',
payer_name='Andrey',
payer_surname='Lebedev',
payment_provider='dnb')
c0 = coupons[0]
self.maxDiff = None
formatted = model.jsonify(c0)
self.assertDictContainsSubset(
{'order': {'__key': 'agx0ZXN0YmVkLXRlc3RyDAsSBU9yZGVyIgExDA',
'__name': u'1',
'__path': [u'Order', u'1'],
'coupon_type': u'test',
'create_time': '2012-01-04T00:00:00',
'currency': u'EUR',
'notes': None,
'paid_amount': 100.0,
'paid_currency': 'EUR',
'payer_email': u'*****@*****.**',
'payer_name': 'Andrey',
'payer_surname': 'Lebedev',
'payment_provider': None,
'payment_time': '2012-01-04T00:00:00',
'price': 300.0,
'quantity': 1L,
'status': 2,
'test': True},
'status': 1,
'use_time': None},
formatted,
)
self.assertIn('__key', formatted)
self.assertIn('__name', formatted)
self.assertIn('__path', formatted)
def test_callback_success(self, send_mail_mock):
# Create test order
ct = model.CouponType('test', 200.0, 'Test coupon')
order = model.order_create('1', ct)
# Prepare request as webtopay would
req = {'orderid': '1',
'payamount': '20000',
'paycurrency': 'LTL',
'p_email': '*****@*****.**',
'status': '1',
'name': 'Bill',
'surename': 'Gates',
'payment': 'test'}
data = webtopay._safe_base64_encode(
webtopay._prepare_query_string(req, 'test'))
signature = webtopay._sign(data, 'pass')
app = create_testapp()
params = {'data': data, 'ss1': signature}
with mock.patch('soaringcoupons.model.coupon_gen_id') as m:
m.return_value = '1001'
resp = app.get('/callback', params=params)
self.assertEqual(resp.body, 'OK')
# Check order status
order = model.order_get('1')
self.assertEqual(order.status, model.Order.ST_PAID)
# Check coupon status
coupon = model.coupon_get('1001')
self.assertNotEqual(coupon, None)
self.assertEqual(coupon.status, model.Coupon.ST_ACTIVE)
# Make sure email was sent
self.assertEqual(len(send_mail_mock.mock_calls), 1)
# Make sure email contains correct link to coupon
msg = send_mail_mock.mock_calls[0][2]
msg_contents = msg['body']
self.assertRegexpMatches(msg_contents, r'http://.*/coupon/1001')
