Fix tests: evaluation of total for json results

4 files changed, 41 insertions, 41 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index 6ac1e6873..05b8a75b1 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -433,19 +433,19 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         search = {'parcel__town': base_town.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
         # parent search
         search = {'parcel__town': parent_town.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
         # child search
         search = {'parcel__town': child_town.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
     def testSearchExport(self):
         c = Client()
@@ -454,24 +454,24 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         self.assertTrue(not json.loads(response.content))
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-contextrecord'))
-        self.assertTrue(json.loads(response.content)['total'] == 2)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 2)
         # test search label
         response = c.get(reverse('get-contextrecord'),
                          {'label': 'cr 1'})
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
         # test search between relations
         response = c.get(reverse('get-contextrecord'),
                          {'label': 'cr 1',
                           'cr_relation_types_0': self.cr_rel_type.pk})
-        self.assertEqual(json.loads(response.content)['total'], 2)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
         # test search vector
         response = c.get(reverse('get-contextrecord'),
                          {'search_vector': 'CR'})
-        self.assertEqual(json.loads(response.content)['total'], 2)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
         # the 2 context records have the same operation
         response = c.get(reverse('get-contextrecord'),
                          {'search_vector': 'op2010'})
-        self.assertEqual(json.loads(response.content)['total'], 2)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
         # test search between related operations
         first_ope = self.operations[0]
         first_ope.year = 2010
@@ -494,7 +494,7 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         response = c.get(reverse('get-contextrecord'),
                          {'operation__year': 2010,
                           'ope_relation_types_0': rel_ope.pk})
-        self.assertEqual(json.loads(response.content)['total'], 2)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
         # export
         response = c.get(reverse('get-contextrecord-full',
                                  kwargs={'type': 'csv'}), {'submited': '1'})
@@ -525,7 +525,7 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content)
-        self.assertTrue(res['total'] == 1)
+        self.assertTrue(res['recordsTotal'] == 1)
         self.assertEqual(res["rows"][0]["unit"],
                          unicode(neg))
 
@@ -533,13 +533,13 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         search = {'unit': dest.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 0)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
 
         # one result for the father
         search = {'unit': su.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
     def testPeriodHierarchicSearch(self):
         cr = self.context_records[0]
@@ -565,19 +565,19 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content)
-        self.assertTrue(res['total'] == 1)
+        self.assertTrue(res['recordsTotal'] == 1)
 
         # no result for the brother
         search = {'datings__period': recent_neo.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 0)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
 
         # one result for the father
         search = {'datings__period': neo.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
 
 class RecordRelationsTest(ContextRecordInit, TestCase):
diff --git a/archaeological_files/tests.py b/archaeological_files/tests.py
index 8ed85610e..837e55c59 100644
--- a/archaeological_files/tests.py
+++ b/archaeological_files/tests.py
@@ -152,8 +152,8 @@ class FileTest(TestCase, FileInit):
             '/get-file/', {'numeric_reference': self.item.numeric_reference})
         self.assertEqual(response.status_code, 200)
         data = json.loads(response.content)
-        self.assertTrue('records' in data)
-        self.assertTrue(data['records'] == 1)
+        self.assertTrue('recordsTotal' in data)
+        self.assertEqual(data['recordsTotal'], 1)
 
     def testRESTGetOldFile(self):
         initial_ref = self.item.internal_reference
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 7f4ce388a..825eb4385 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -511,7 +511,7 @@ class FindSearchTest(FindInit, TestCase):
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content)
-        self.assertTrue(res['total'] == 1)
+        self.assertTrue(res['recordsTotal'] == 1)
         self.assertEqual(res["rows"][0]["material_types__label"],
                          unicode(iron_metal))
 
@@ -519,13 +519,13 @@ class FindSearchTest(FindInit, TestCase):
         search = {'material_types': not_iron_metal.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(json.loads(response.content)['total'] == 0)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 0)
 
         # one result for the father
         search = {'material_types': metal.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
 
     def test_pinned_search(self):
         c = Client()
@@ -536,7 +536,7 @@ class FindSearchTest(FindInit, TestCase):
         c.get(reverse("pin", args=["operation", operation.pk]))
         response = c.get(reverse('get-find'), {})  # empty search -> check pined
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 0)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
 
         # pinned operation with current find
         find = self.finds[0]
@@ -546,7 +546,7 @@ class FindSearchTest(FindInit, TestCase):
                   find.get_first_base_find().context_record.operation.pk]))
         response = c.get(reverse('get-find'), {})  # empty search -> check pined
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
 
     def testPeriodHierarchicSearch(self):
@@ -573,7 +573,7 @@ class FindSearchTest(FindInit, TestCase):
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content)
-        self.assertTrue(res['total'] == 1)
+        self.assertTrue(res['recordsTotal'] == 1)
         self.assertEqual(res["rows"][0]["datings__period__label"],
                          unicode(final_neo))
 
@@ -581,13 +581,13 @@ class FindSearchTest(FindInit, TestCase):
         search = {'datings__period': recent_neo.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 0)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
 
         # one result for the father
         search = {'datings__period': neo.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
     def testConservatoryStateHierarchicSearch(self):
         find = self.finds[0]
@@ -615,19 +615,19 @@ class FindSearchTest(FindInit, TestCase):
         # one result for exact search
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
 
         # no result for the brother
         search = {'conservatory_state': cs3.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(json.loads(response.content)['total'] == 0)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 0)
 
         # one result for the father
         search = {'conservatory_state': cs1.pk}
         response = c.get(reverse('get-find'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
 
 
 class PackagingTest(FindInit, TestCase):
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 43dd57018..166e535ca 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -1263,11 +1263,11 @@ class OperationSearchTest(TestCase, OperationInitTest):
         self.assertTrue(not json.loads(response.content))
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-operation'), {'year': '2010'})
-        self.assertEqual(json.loads(response.content)['total'], 2)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
         response = c.get(reverse('get-operation'),
                          {'operator': self.orgas[0].pk})
         result = json.loads(response.content)
-        self.assertEqual(result['total'], 2)
+        self.assertEqual(result['recordsTotal'], 2)
 
     def create_relations(self):
         rel1 = models.RelationType.objects.create(
@@ -1292,7 +1292,7 @@ class OperationSearchTest(TestCase, OperationInitTest):
         self.assertTrue(not json.loads(response.content))
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-operation'), search)
-        self.assertTrue(json.loads(response.content)['total'] == 2)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 2)
 
     def testHierarchicSearch(self):
         ope = self.operations[1]
@@ -1315,19 +1315,19 @@ class OperationSearchTest(TestCase, OperationInitTest):
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content)
-        self.assertTrue(res['total'] == 1)
+        self.assertTrue(res['recordsTotal'] == 1)
 
         # no result for the brother
         search = {'periods': recent_neo.pk}
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 0)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
 
         # one result for the father
         search = {'periods': neo.pk}
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
     def test_town_search(self):
         c = Client()
@@ -1351,19 +1351,19 @@ class OperationSearchTest(TestCase, OperationInitTest):
         search = {'towns': base_town.pk}
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
         # parent search
         search = {'towns': parent_town.pk}
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
         # child search
         search = {'towns': child_town.pk}
         response = c.get(reverse('get-operation'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['total'], 1)
+        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
 
     def testOwnSearch(self):
         c = Client()
@@ -1373,10 +1373,10 @@ class OperationSearchTest(TestCase, OperationInitTest):
         c.login(username=self.alt_username, password=self.alt_password)
         response = c.get(reverse('get-operation'), {'year': '2010'})
         # only one "own" operation available
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
         response = c.get(reverse('get-operation'),
                          {'operator': self.orgas[0].pk})
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
 
 
 class DashboardTest(TestCase, OperationInitTest):
@@ -1426,9 +1426,9 @@ class RegisterTest(TestCase, OperationInitTest):
         self.assertTrue(not json.loads(response.content))
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-administrativeact'), {'year': '2014'})
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
         response = c.get(reverse('get-administrativeact'), {'indexed': '2'})
-        self.assertTrue(json.loads(response.content)['total'] == 1)
+        self.assertTrue(json.loads(response.content)['recordsTotal'] == 1)
 
     def test_document_generation(self):
         tpl = open(