clean up

src/tests/base/test_self_service_cancellation.py

@@ -9,6 +9,8 @@ from freezegun import freeze_time
 
 from pretix.base.models import Event, Item, Order, OrderPosition, Organizer
 from pretix.base.models.cancellation import CancellationRule, Ruling
+from pretix.base.models.cancellation import CheckRes
+from pretix.base.models.cancellation import OrderDiff
 
 NOW = now()
 DAYS_UNTIL_EVENT=60
@@ -51,24 +53,28 @@ def test_status_rule(event, item1, order):
         )
 
         cancellation_rule = CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
-            order_status=Order.STATUS_PENDING
+            organizer=event.organizer, event=event,
+            allowed_if_in_order_status=Order.STATUS_PENDING
         )
+        cancellation_rule.items.set([item1])
 
-        assert cancellation_rule._rule_order_status(order_position=op) == {
-            'ORDER_STATUS': Ruling(
+        diff = OrderDiff.cancel_all(order)
+
+        assert cancellation_rule._check_order_status(diff=diff, order_position=op) == {
+            'ORDER_STATUS': CheckRes(
                 cancellation_possible=True,
                 reason="Order in required status: 'n'",
             ),
         }
 
         cancellation_rule = CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
-            order_status=Order.STATUS_PAID
+            organizer=event.organizer, event=event,
+            allowed_if_in_order_status=Order.STATUS_PAID
         )
+        cancellation_rule.items.set([item1])
 
-        assert cancellation_rule._rule_order_status(order_position=op) == {
-            'ORDER_STATUS': Ruling(
+        assert cancellation_rule._check_order_status(diff=diff, order_position=op) == {
+            'ORDER_STATUS': CheckRes(
                 cancellation_possible=False,
                 reason="Order in status 'n' cannot be canceled",
             ),
@@ -86,17 +92,21 @@ def test_timing(event, item1, order):
             price=Decimal("0.00"), attendee_name_parts={'full_name': "Peter"}, positionid=1
         )
 
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr1 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=now() + timedelta(hours=1),
         )
+        cr1.items.set([item1])
+
+
+        diff = OrderDiff.cancel_all(order)
 
         with freeze_time(now()):
-            possible, verdicts = CancellationRule.objects.all().cancellation_possible(order)
+            possible, verdicts = CancellationRule.objects.all().cancellation_possible(diff)
             assert possible == True
 
         with freeze_time(now()+timedelta(hours=2)):
-            possible, verdicts=CancellationRule.objects.all().cancellation_possible(order)
+            possible, verdicts=CancellationRule.objects.all().cancellation_possible(diff)
             assert possible == False
 
 
@@ -112,37 +122,52 @@ def test_multiple_limits(event, item1, order):
         )
 
         # free in the first hour after booking
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr1=CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=NOW + timedelta(hours=1),
         )
+        cr1.items.set([item1])
 
         # free until 30 days before event
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr2 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=EVENT_START - timedelta(days=30),
         )
+        cr2.items.set([item1])
 
         # 50% until 14 days before event
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr3 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=EVENT_START - timedelta(days=14),
             fee_percentage_per_item=Decimal(50.0)
         )
+        cr3.items.set([item1])
 
         # 80% until 7 days before event
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr4 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=EVENT_START - timedelta(days=7),
             fee_percentage_per_item=Decimal(80.0)
         )
+        cr4.items.set([item1])
 
         # 100% until 1 day before event
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
+        cr5 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
             allowed_until=EVENT_START - timedelta(days=1),
             fee_percentage_per_item=Decimal(100)
         )
+        cr5.items.set([item1])
+
+        # Cancellation is not allowed at all, but rule doesn't match the item
+        CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
+            allowed_until=NOW,
+            fee_percentage_per_item=Decimal(100)
+        )
+
+
+        diff = OrderDiff.cancel_all(order)
 
         possible_trace = []
         cost_trace = []
@@ -151,7 +176,7 @@ def test_multiple_limits(event, item1, order):
             today = NOW + timedelta(days=days)
             with freeze_time(today):
                 possible, verdicts=CancellationRule.objects.all().cancellation_possible(
-                    order)
+                    diff)
                 possible_trace.append(possible)
                 cost_trace.append(verdicts[0].total_fee)
 
@@ -173,16 +198,21 @@ def test_cancellation_rule_query_set(event, item1, order):
             price=Decimal("0.00"), attendee_name_parts={'full_name': "Peter"}, positionid=1
         )
 
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
-            order_status=Order.STATUS_PENDING, fee_absolute_per_order=Decimal('10.00'),
+        cr1 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
+            allowed_if_in_order_status=Order.STATUS_PENDING, fee_absolute_per_order=Decimal('10.00'),
         )
+        cr1.items.set([item1])
 
-        CancellationRule.objects.create(
-            organizer=event.organizer, event=event, item=item1,
-            order_status=Order.STATUS_PAID
+
+        cr2 = CancellationRule.objects.create(
+            organizer=event.organizer, event=event,
+            allowed_if_in_order_status=Order.STATUS_PAID
         )
+        cr2.items.set([item1])
 
-        possible, verdicts = CancellationRule.objects.all().cancellation_possible(order)
+        diff = OrderDiff.cancel_all(order)
+
+        possible, verdicts = CancellationRule.objects.all().cancellation_possible(diff)
 
         assert  possible == True