From ed40b9e3e292911ef839c758a53ce8bd09082516 Mon Sep 17 00:00:00 2001
From: Charlie Denton <charlie@meshy.co.uk>
Date: Wed, 17 Jan 2018 22:01:02 +0000
Subject: [PATCH] Use assertRegex to ignore object IDs

Sometimes the tests failed because these objects had IDs that differed
from expectations. As the IDs are not relevant to this test, I have
replaced the exact string match with a regex match that accepts any ID.
---
 polymorphic/tests/test_orm.py | 52 +++++++++++++++++------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/polymorphic/tests/test_orm.py b/polymorphic/tests/test_orm.py
index 9500606..335d450 100644
--- a/polymorphic/tests/test_orm.py
+++ b/polymorphic/tests/test_orm.py
@@ -228,14 +228,14 @@ class PolymorphicTests(TransactionTestCase):
         objects_deferred = Model2A.objects.defer('field1')
 
         self.assertNotIn('field1', objects_deferred[0].__dict__, 'field1 was not deferred (using defer())')
-        self.assertEqual(repr(objects_deferred[0]),
-                         '<Model2A: id 1, field1 (CharField), deferred[field1]>')
-        self.assertEqual(repr(objects_deferred[1]),
-                         '<Model2B: id 2, field1 (CharField), field2 (CharField), deferred[field1]>')
-        self.assertEqual(repr(objects_deferred[2]),
-                         '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField), deferred[field1]>')
-        self.assertEqual(repr(objects_deferred[3]),
-                         '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField), deferred[field1]>')
+        self.assertRegex(repr(objects_deferred[0]),
+                         '<Model2A: id \d+, field1 \(CharField\), deferred\[field1\]>')
+        self.assertRegex(repr(objects_deferred[1]),
+                         '<Model2B: id \d+, field1 \(CharField\), field2 \(CharField\), deferred\[field1\]>')
+        self.assertRegex(repr(objects_deferred[2]),
+                         '<Model2C: id \d+, field1 \(CharField\), field2 \(CharField\), field3 \(CharField\), deferred\[field1\]>')
+        self.assertRegex(repr(objects_deferred[3]),
+                         '<Model2D: id \d+, field1 \(CharField\), field2 \(CharField\), field3 \(CharField\), field4 \(CharField\), deferred\[field1\]>')
 
         objects_only = Model2A.objects.only('pk', 'polymorphic_ctype', 'field1')
 
@@ -246,33 +246,33 @@ class PolymorphicTests(TransactionTestCase):
                       ' on a child model')
         self.assertNotIn('field4', objects_only[3].__dict__,
                          'field4 was not deferred (using only())')
-        self.assertEqual(repr(objects_only[0]),
-                         '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects_only[1]),
-                         '<Model2B: id 2, field1 (CharField), field2 (CharField), deferred[field2]>')
-        self.assertEqual(repr(objects_only[2]),
-                         '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField), '
-                         'deferred[field2,field3,model2a_ptr_id]>')
-        self.assertEqual(repr(objects_only[3]),
-                         '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField), '
-                         'deferred[field2,field3,field4,model2a_ptr_id,model2b_ptr_id]>')
+        self.assertRegex(repr(objects_only[0]),
+                         '<Model2A: id \d+, field1 \(CharField\)>')
+        self.assertRegex(repr(objects_only[1]),
+                         '<Model2B: id \d+, field1 \(CharField\), field2 \(CharField\), deferred\[field2\]>')
+        self.assertRegex(repr(objects_only[2]),
+                         '<Model2C: id \d+, field1 \(CharField\), field2 \(CharField\), field3 \(CharField\), '
+                         'deferred\[field2,field3,model2a_ptr_id\]>')
+        self.assertRegex(repr(objects_only[3]),
+                         '<Model2D: id \d+, field1 \(CharField\), field2 \(CharField\), field3 \(CharField\), field4 \(CharField\), '
+                         'deferred\[field2,field3,field4,model2a_ptr_id,model2b_ptr_id\]>')
 
         ModelX.objects.create(field_b="A1", field_x="A2")
         ModelY.objects.create(field_b="B1", field_y="B2")
 
         objects_deferred = Base.objects.defer('ModelY___field_y')
-        self.assertEqual(repr(objects_deferred[0]),
-                         '<ModelX: id 3, field_b (CharField), field_x (CharField)>')
-        self.assertEqual(repr(objects_deferred[1]),
-                         '<ModelY: id 4, field_b (CharField), field_y (CharField), deferred[field_y]>')
+        self.assertRegex(repr(objects_deferred[0]),
+                         '<ModelX: id \d+, field_b \(CharField\), field_x \(CharField\)>')
+        self.assertRegex(repr(objects_deferred[1]),
+                         '<ModelY: id \d+, field_b \(CharField\), field_y \(CharField\), deferred\[field_y\]>')
 
         objects_only = Base.objects.only(
             'polymorphic_ctype', 'ModelY___field_y', 'ModelX___field_x',
         )
-        self.assertEqual(repr(objects_only[0]),
-                         '<ModelX: id 3, field_b (CharField), field_x (CharField), deferred[field_b]>')
-        self.assertEqual(repr(objects_only[1]),
-                         '<ModelY: id 4, field_b (CharField), field_y (CharField), deferred[field_b]>')
+        self.assertRegex(repr(objects_only[0]),
+                         '<ModelX: id \d+, field_b \(CharField\), field_x \(CharField\), deferred\[field_b\]>')
+        self.assertRegex(repr(objects_only[1]),
+                         '<ModelY: id \d+, field_b \(CharField\), field_y \(CharField\), deferred\[field_b\]>')
 
     def test_defer_related_fields(self):
         self.create_model2abcd()