Add some tests

src/pretix/base/payment.py

@@ -971,7 +971,7 @@ class GiftCardPayment(BasePaymentProvider):
                 messages.error(request, _("This gift card can only be used in test mode."))
                 return
             if not gc.testmode and self.event.testmode:
-                messages.error(request, _("Only test gifts cards can be used in test mode."))
+                messages.error(request, _("Only test gift cards can be used in test mode."))
                 return
             if gc.value <= Decimal("0.00"):
                 messages.error(request, _("All credit on this gift card has been used."))
@@ -1017,10 +1017,10 @@ class GiftCardPayment(BasePaymentProvider):
             if gc.currency != self.event.currency:
                 messages.error(request, _("This gift card does not support this currency."))
                 return
-            if gc.testmode and not self.event.testmode:
+            if gc.testmode and not payment.order.testmode:
                 messages.error(request, _("This gift card can only be used in test mode."))
                 return
-            if not gc.testmode and self.event.testmode:
+            if not gc.testmode and payment.order.testmode:
                 messages.error(request, _("Only test gift cards can be used in test mode."))
                 return
             if gc.value <= Decimal("0.00"):

src/pretix/base/services/orders.py

@@ -292,6 +292,19 @@ def _cancel_order(order, user=None, send_mail: bool=True, api_token=None, device
         if i:
             generate_cancellation(i)
 
+        for position in order.positions.all():
+            for gc in position.issued_gift_cards.all():
+                gc = GiftCard.objects.select_for_update().get(pk=gc.pk)
+                if gc.value < position.price:
+                    raise OrderError(
+                        _('This order can not be canceled since the gift card {card} purchased in '
+                          'this order has already been redeemed.').format(
+                            card=gc.secret
+                        )
+                    )
+                else:
+                    gc.transactions.create(value=-position.price, order=order)
+
         if cancellation_fee:
             with order.event.lock():
                 for position in order.positions.all():
@@ -329,15 +342,6 @@ def _cancel_order(order, user=None, send_mail: bool=True, api_token=None, device
                 if position.voucher:
                     Voucher.objects.filter(pk=position.voucher.pk).update(redeemed=Greatest(0, F('redeemed') - 1))
 
-        for position in order.positions.all():
-            for gc in position.issued_gift_cards.all():
-                if gc.value < position.price:
-                    raise OrderError(_('This order can not be canceled since the gift card {card} purchased in this order has already been redeemed.').format(
-                        card=gc.secret
-                    ))
-                else:
-                    gc.transactions.create(value=-position.price, order=order)
-
         order.log_action('pretix.event.order.canceled', user=user, auth=api_token or oauth_application or device,
                          data={'cancellation_fee': cancellation_fee})
 
@@ -1257,6 +1261,17 @@ class OrderChangeManager:
                 op.position._calculate_tax()
                 op.position.save()
             elif isinstance(op, self.CancelOperation):
+                for gc in op.position.issued_gift_cards.all():
+                    gc = GiftCard.objects.select_for_update().get(pk=gc.pk)
+                    if gc.value < op.position.price:
+                        raise OrderError(_(
+                            'A position can not be canceled since the gift card {card} purchased in this order has '
+                            'already been redeemed.').format(
+                            card=gc.secret
+                        ))
+                    else:
+                        gc.transactions.create(value=-op.position.price, order=self.order)
+
                 for opa in op.position.addons.all():
                     self.order.log_action('pretix.event.order.changed.cancel', user=self.user, auth=self.auth, data={
                         'position': opa.pk,
@@ -1692,10 +1707,13 @@ def signal_listener_issue_giftcards(sender: Event, order: Order, **kwargs):
     any_giftcards = False
     for p in order.positions.all():
         if p.item.issue_giftcard:
+            issued = Decimal('0.00')
+            for gc in p.issued_gift_cards.all():
+                issued += gc.transactions.first().value
             gc = sender.organizer.issued_gift_cards.create(
                 currency=sender.currency, issued_in=p, testmode=order.testmode
             )
-            gc.transactions.create(value=p.price, order=order)
+            gc.transactions.create(value=p.price - issued, order=order)
             any_giftcards = True
             p.secret = gc.secret
             p.save(update_fields=['secret'])

src/pretix/control/forms/organizer.py

@@ -341,10 +341,10 @@ class GiftCardCreateForm(forms.ModelForm):
         self.organizer = kwargs.pop('organizer')
         super().__init__(*args, **kwargs)
 
-    def validate_secret(self):
+    def clean_secret(self):
         s = self.cleaned_data['secret']
         if GiftCard.objects.filter(
-            secret=s
+            secret__iexact=s
         ).filter(
             Q(issuer=self.organizer) | Q(issuer__gift_card_collector_acceptance__collector=self.organizer)
         ).exists():

src/tests/api/conftest.py

@@ -156,6 +156,12 @@ def taxrule(event):
     return event.tax_rules.create(name="VAT", rate=19)
 
 
+@pytest.fixture
+@scopes_disabled()
+def taxrule0(event):
+    return event.tax_rules.create(name="VAT", rate=0)
+
+
 @pytest.fixture
 @scopes_disabled()
 def taxrule2(event2):

src/tests/api/test_items.py

@@ -463,6 +463,75 @@ def test_item_create_with_variation(token_client, organizer, event, item, catego
         assert new_item.variations.first().value.localize('en') == "Comment"
 
 
+@pytest.mark.django_db
+def test_item_create_giftcard_validation(token_client, organizer, event, item, category, category2, taxrule, taxrule0):
+    resp = token_client.post(
+        '/api/v1/organizers/{}/events/{}/items/'.format(organizer.slug, event.slug),
+        {
+            "category": category.pk,
+            "name": {
+                "en": "Ticket"
+            },
+            "active": True,
+            "description": None,
+            "default_price": "23.00",
+            "free_price": False,
+            "tax_rate": "19.00",
+            "tax_rule": taxrule0.pk,
+            "admission": True,
+            "issue_giftcard": True,
+            "position": 0,
+            "picture": None,
+            "available_from": None,
+            "available_until": None,
+            "require_voucher": False,
+            "hide_without_voucher": False,
+            "allow_cancel": True,
+            "min_per_order": None,
+            "max_per_order": None,
+            "checkin_attention": False,
+            "has_variations": True,
+            "addons": []
+        },
+        format='json'
+    )
+    assert resp.status_code == 400
+    assert resp.content.decode() == '{"non_field_errors":["Gift card products should not be admission products at the same time."]}'
+    resp = token_client.post(
+        '/api/v1/organizers/{}/events/{}/items/'.format(organizer.slug, event.slug),
+        {
+            "category": category.pk,
+            "name": {
+                "en": "Ticket"
+            },
+            "active": True,
+            "description": None,
+            "default_price": "23.00",
+            "free_price": False,
+            "tax_rate": "19.00",
+            "tax_rule": taxrule.pk,
+            "admission": False,
+            "issue_giftcard": True,
+            "position": 0,
+            "picture": None,
+            "available_from": None,
+            "available_until": None,
+            "require_voucher": False,
+            "hide_without_voucher": False,
+            "allow_cancel": True,
+            "min_per_order": None,
+            "max_per_order": None,
+            "checkin_attention": False,
+            "has_variations": True,
+            "addons": []
+        },
+        format='json'
+    )
+    assert resp.status_code == 400
+    assert resp.content.decode() == '{"non_field_errors":["Gift card products should not be associated with non-zero ' \
+                                    'tax rates since sales tax will be applied when the gift card is redeemed."]}'
+
+
 @pytest.mark.django_db
 def test_item_create_with_addon(token_client, organizer, event, item, category, category2, taxrule):
     resp = token_client.post(

src/tests/base/test_models.py

@@ -1074,6 +1074,17 @@ class OrderTestCase(BaseQuotaTestCase):
         self.event.settings.cancel_allow_user = False
         assert not self.order.user_cancel_allowed
 
+    @classscope(attr='o')
+    def test_can_cancel_order_with_giftcard(self):
+        item1 = Item.objects.create(event=self.event, name="Ticket", default_price=23,
+                                    admission=True, allow_cancel=True, issue_giftcard=True)
+        p = OrderPosition.objects.create(order=self.order, item=item1,
+                                         variation=None, price=23)
+        self.event.organizer.issued_gift_cards.create(
+            currency="EUR", issued_in=p
+        )
+        assert not self.order.user_cancel_allowed
+
     @classscope(attr='o')
     def test_can_cancel_order_free(self):
         self.order.status = Order.STATUS_PAID

src/tests/base/test_orders.py

@@ -592,6 +592,52 @@ class OrderCancelTests(TestCase):
         assert self.order.all_logentries().filter(action_type='pretix.event.order.refund.created').exists()
         assert not self.order.all_logentries().filter(action_type='pretix.event.order.refund.requested').exists()
 
+    @classscope(attr='o')
+    def test_auto_refund_possible_giftcard(self):
+        gc = self.o.issued_gift_cards.create(currency="EUR")
+        p1 = self.order.payments.create(
+            amount=Decimal('46.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='giftcard',
+            info='{"gift_card": %d}' % gc.pk
+        )
+        cancel_order(self.order.pk, cancellation_fee=2, try_auto_refund=True)
+        r = self.order.refunds.get()
+        assert r.state == OrderRefund.REFUND_STATE_DONE
+        assert r.amount == Decimal('44.00')
+        assert r.source == OrderRefund.REFUND_SOURCE_BUYER
+        assert r.payment == p1
+        assert self.order.all_logentries().filter(action_type='pretix.event.order.refund.created').exists()
+        assert not self.order.all_logentries().filter(action_type='pretix.event.order.refund.requested').exists()
+        assert gc.value == Decimal('44.00')
+
+    @classscope(attr='o')
+    def test_auto_refund_possible_issued_giftcard(self):
+        gc = self.o.issued_gift_cards.create(currency="EUR", issued_in=self.op1)
+        gc.transactions.create(value=23)
+        self.order.payments.create(
+            amount=Decimal('46.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_partialrefund'
+        )
+        cancel_order(self.order.pk, cancellation_fee=2, try_auto_refund=True)
+        r = self.order.refunds.get()
+        assert r.state == OrderRefund.REFUND_STATE_DONE
+        assert gc.value == Decimal('0.00')
+
+    @classscope(attr='o')
+    def test_auto_refund_impossible_issued_giftcard_used(self):
+        gc = self.o.issued_gift_cards.create(currency="EUR", issued_in=self.op1)
+        gc.transactions.create(value=20)
+        self.order.payments.create(
+            amount=Decimal('46.00'),
+            state=OrderPayment.PAYMENT_STATE_CONFIRMED,
+            provider='testdummy_partialrefund'
+        )
+        with pytest.raises(OrderError):
+            cancel_order(self.order.pk, cancellation_fee=2, try_auto_refund=True)
+        assert gc.value == Decimal('20.00')
+
     @classscope(attr='o')
     def test_auto_refund_impossible(self):
         self.order.payments.create(
@@ -859,6 +905,22 @@ class OrderChangeManagerTests(TestCase):
         assert self.op1.price == Decimal('24.00')
         assert self.order.status == Order.STATUS_PENDING
 
+    @classscope(attr='o')
+    def test_cancel_issued_giftcard(self):
+        gc = self.o.issued_gift_cards.create(currency="EUR", issued_in=self.op1)
+        gc.transactions.create(value=23)
+        self.ocm.cancel(self.op1)
+        self.ocm.commit()
+        assert gc.value == Decimal('0.00')
+
+    @classscope(attr='o')
+    def test_cancel_issued_giftcard_used(self):
+        gc = self.o.issued_gift_cards.create(currency="EUR", issued_in=self.op1)
+        gc.transactions.create(value=20)
+        self.ocm.cancel(self.op1)
+        with self.assertRaises(OrderError):
+            self.ocm.commit()
+
     @classscope(attr='o')
     def test_cancel_all_in_order(self):
         self.ocm.cancel(self.op1)

src/tests/control/test_giftcards.py

@@ -0,0 +1,125 @@
+import pytest
+
+from pretix.base.models import Organizer, Team, User
+
+
+@pytest.fixture
+def organizer():
+    return Organizer.objects.create(name='Dummy', slug='dummy')
+
+
+@pytest.fixture
+def organizer2():
+    return Organizer.objects.create(name='Partner', slug='partner')
+
+
+@pytest.fixture
+def gift_card(organizer):
+    gc = organizer.issued_gift_cards.create(currency="EUR")
+    gc.transactions.create(value=42)
+    return gc
+
+
+@pytest.fixture
+def admin_user(organizer):
+    u = User.objects.create_user('dummy@dummy.dummy', 'dummy')
+    admin_team = Team.objects.create(organizer=organizer, can_manage_gift_cards=True, name='Admin team')
+    admin_team.members.add(u)
+    return u
+
+
+@pytest.fixture
+def team2(admin_user, organizer2):
+    admin_team = Team.objects.create(organizer=organizer2, can_manage_gift_cards=True, name='Admin team')
+    admin_team.members.add(admin_user)
+
+
+@pytest.mark.django_db
+def test_list_of_cards(organizer, admin_user, client, gift_card):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    resp = client.get('/control/organizer/dummy/giftcards')
+    assert gift_card.secret in resp.content.decode()
+    resp = client.get('/control/organizer/dummy/giftcards?query=' + gift_card.secret[:3])
+    assert gift_card.secret in resp.content.decode()
+    resp = client.get('/control/organizer/dummy/giftcards?query=1234_FOO')
+    assert gift_card.secret not in resp.content.decode()
+
+
+@pytest.mark.django_db
+def test_card_detail_view(organizer, admin_user, gift_card, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    resp = client.get('/control/organizer/dummy/giftcard/{}/'.format(gift_card.pk))
+    assert gift_card.secret in resp.content.decode()
+    assert '42.00' in resp.content.decode()
+
+
+@pytest.mark.django_db
+def test_card_add(organizer, admin_user, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    resp = client.post('/control/organizer/dummy/giftcard/add', {
+        'currency': 'EUR',
+        'secret': 'FOOBAR',
+        'value': '42.00',
+        'testmode': 'on'
+    }, follow=True)
+    assert 'TEST MODE' in resp.content.decode()
+    assert '42.00' in resp.content.decode()
+    resp = client.post('/control/organizer/dummy/giftcard/add', {
+        'currency': 'EUR',
+        'secret': 'FOOBAR',
+        'value': '42.00',
+        'testmode': 'on'
+    }, follow=True)
+    assert 'has-error' in resp.content.decode()
+
+
+@pytest.mark.django_db
+def test_card_detail_view_transact(organizer, admin_user, gift_card, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    client.post('/control/organizer/dummy/giftcard/{}/'.format(gift_card.pk), {
+        'value': '23.00'
+    })
+    assert gift_card.value == 23 + 42
+    assert gift_card.all_logentries().count() == 1
+
+
+@pytest.mark.django_db
+def test_card_detail_view_transact_min_value(organizer, admin_user, gift_card, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    r = client.post('/control/organizer/dummy/giftcard/{}/'.format(gift_card.pk), {
+        'value': '-50.00'
+    })
+    assert 'alert-danger' in r.rendered_content
+    assert gift_card.value == 42
+
+
+@pytest.mark.django_db
+def test_card_detail_view_transact_invalid_value(organizer, admin_user, gift_card, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    r = client.post('/control/organizer/dummy/giftcard/{}/'.format(gift_card.pk), {
+        'value': 'foo'
+    })
+    assert 'alert-danger' in r.rendered_content
+    assert gift_card.value == 42
+
+
+@pytest.mark.django_db
+def test_manage_acceptance(organizer, organizer2, admin_user, gift_card, client, team2):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    client.post('/control/organizer/dummy/giftcards'.format(gift_card.pk), {
+        'add': organizer2.slug
+    })
+    assert organizer.gift_card_issuer_acceptance.filter(issuer=organizer2).exists()
+    client.post('/control/organizer/dummy/giftcards'.format(gift_card.pk), {
+        'del': organizer2.slug
+    })
+    assert not organizer.gift_card_issuer_acceptance.filter(issuer=organizer2).exists()
+
+
+@pytest.mark.django_db
+def test_manage_acceptance_permission_required(organizer, organizer2, admin_user, gift_card, client):
+    client.login(email='dummy@dummy.dummy', password='dummy')
+    client.post('/control/organizer/dummy/giftcards'.format(gift_card.pk), {
+        'add': organizer2.slug
+    })
+    assert not organizer.gift_card_issuer_acceptance.filter(issuer=organizer2).exists()

src/tests/control/test_items.py

@@ -419,6 +419,22 @@ class ItemsTest(ItemFormTest):
         self.item1.refresh_from_db()
         assert self.item1.default_price == Decimal('23.00')
 
+    def test_update_validate_giftcard(self):
+        doc = self.get_doc('/control/event/%s/%s/items/%d/' % (self.orga1.slug, self.event1.slug, self.item2.id))
+        d = extract_form_fields(doc.select('.container-fluid form')[0])
+        d.update({
+            'name_0': 'Standard',
+            'default_price': '23.00',
+            'admission': 'on',
+            'issue_giftcard': 'on',
+            'active': 'yes',
+            'allow_cancel': 'yes',
+            'sales_channels': 'web'
+        })
+        self.client.post('/control/event/%s/%s/items/%d/' % (self.orga1.slug, self.event1.slug, self.item1.id), d)
+        self.item1.refresh_from_db()
+        assert not self.item1.issue_giftcard
+
     def test_manipulate_addons(self):
         doc = self.get_doc('/control/event/%s/%s/items/%d/' % (self.orga1.slug, self.event1.slug, self.item2.id))
         d = extract_form_fields(doc.select('.container-fluid form')[0])

src/tests/presale/test_checkout.py

@@ -795,6 +795,239 @@ class CheckoutTestCase(BaseCheckoutTestCase, TestCase):
         doc = BeautifulSoup(response.rendered_content, "lxml")
         assert doc.select(".alert-danger")
 
+    def test_giftcard_partial(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_stripe__enabled', True)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.get('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select('input[name="payment"]')), 3)
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        self.assertRedirects(response, '/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug),
+                             target_status_code=200)
+        assert '-€20.00' in response.rendered_content
+        assert '3.00' in response.rendered_content
+        assert 'alert-success' in response.rendered_content
+
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'banktransfer',
+        }, follow=True)
+        self.assertRedirects(response, '/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug),
+                             target_status_code=200)
+        assert '-€20.00' in response.rendered_content
+        assert '3.00' in response.rendered_content
+
+        response = self.client.post('/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select(".thank-you")), 1)
+        with scopes_disabled():
+            o = Order.objects.last()
+            assert o.payments.get(provider='giftcard').amount == Decimal('20.00')
+            assert o.payments.get(provider='banktransfer').amount == Decimal('3.00')
+
+        assert '-€20.00' in response.rendered_content
+        assert '3.00' in response.rendered_content
+
+    def test_giftcard_full(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=30)
+        self.event.settings.set('payment_stripe__enabled', True)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.get('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select('input[name="payment"]')), 3)
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        self.assertRedirects(response, '/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug),
+                             target_status_code=200)
+        assert '-€23.00' in response.rendered_content
+        assert '0.00' in response.rendered_content
+
+        response = self.client.post('/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select(".thank-you")), 1)
+        with scopes_disabled():
+            o = Order.objects.last()
+            assert o.payments.get(provider='giftcard').amount == Decimal('23.00')
+
+    def test_giftcard_racecondition(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_stripe__enabled', True)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.get('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select('input[name="payment"]')), 3)
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        self.assertRedirects(response, '/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug),
+                             target_status_code=200)
+        assert '-€20.00' in response.rendered_content
+        assert '3.00' in response.rendered_content
+        assert 'alert-success' in response.rendered_content
+
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'banktransfer',
+        }, follow=True)
+        self.assertRedirects(response, '/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug),
+                             target_status_code=200)
+        assert '-€20.00' in response.rendered_content
+        assert '3.00' in response.rendered_content
+
+        gc.transactions.create(value=-2)
+
+        response = self.client.post('/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select(".alert-danger")), 1)
+        assert '-€18.00' in response.rendered_content
+        assert '5.00' in response.rendered_content
+
+        response = self.client.post('/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug), follow=True)
+        doc = BeautifulSoup(response.rendered_content, "lxml")
+        self.assertEqual(len(doc.select(".thank-you")), 1)
+        with scopes_disabled():
+            o = Order.objects.last()
+            assert o.payments.get(provider='giftcard').amount == Decimal('18.00')
+            assert o.payments.get(provider='banktransfer').amount == Decimal('5.00')
+
+    def test_giftcard_invalid_currency(self):
+        gc = self.orga.issued_gift_cards.create(currency="USD")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'This gift card does not support this currency.' in response.rendered_content
+
+    def test_giftcard_invalid_organizer(self):
+        self.orga.issued_gift_cards.create(currency="EUR")
+        orga2 = Organizer.objects.create(slug="foo2", name="foo2")
+        gc = orga2.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        print(response.rendered_content)
+        assert 'This gift card is not known.' in response.rendered_content
+
+    def test_giftcard_in_test_mode(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        self.event.testmode = True
+        self.event.save()
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'Only test gift cards can be used in test mode.' in response.rendered_content
+
+    def test_giftcard_not_in_test_mode(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR", testmode=True)
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'This gift card can only be used in test mode.' in response.rendered_content
+
+    def test_giftcard_empty(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'All credit on this gift card has been used.' in response.rendered_content
+
+    def test_giftcard_twice(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'This gift card is already used for your payment.' in response.rendered_content
+
+    def test_giftcard_swap(self):
+        gc = self.orga.issued_gift_cards.create(currency="EUR")
+        gc.transactions.create(value=20)
+        self.event.settings.set('payment_banktransfer__enabled', True)
+        self.ticket.issue_giftcard = True
+        self.ticket.save()
+        with scopes_disabled():
+            CartPosition.objects.create(
+                event=self.event, cart_id=self.session_key, item=self.ticket,
+                price=23, expires=now() + timedelta(minutes=10)
+            )
+        response = self.client.post('/%s/%s/checkout/payment/' % (self.orga.slug, self.event.slug), {
+            'payment': 'giftcard',
+            'giftcard': gc.secret
+        }, follow=True)
+        assert 'You cannot pay with gift cards when buying a gift card.' in response.rendered_content
+
     def test_premature_confirm(self):
         response = self.client.get('/%s/%s/checkout/confirm/' % (self.orga.slug, self.event.slug), follow=True)
         self.assertRedirects(response, '/%s/%s/?require_cookie=true' % (self.orga.slug, self.event.slug),