Migrate to python 3 - Clean old migrations and some old scripts

1 files changed, 68 insertions, 40 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index 2f676c194..fe9fab7fb 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -19,13 +19,14 @@
 
 import csv
 import json
-from StringIO import StringIO
+from io import StringIO
 
 from django.conf import settings
 from django.contrib.auth.models import Permission
 from django.core.exceptions import ValidationError, ImproperlyConfigured
 from django.core.urlresolvers import reverse
 from django.test.client import Client
+from django.utils.translation import pgettext_lazy
 
 from ishtar_common.models import IshtarSiteProfile, ImporterModel, \
     UserProfile, ProfileType, Town, Area, get_current_profile
@@ -236,7 +237,8 @@ class ExportTest(ContextRecordInit, TestCase):
         self.assertTrue(not response.content)
         c.login(username=self.username, password=self.password)
         response = c.get(url)
-        rows = list(csv.reader(StringIO(response.content)))
+        ENCODING = settings.ENCODING or 'utf-8'
+        rows = list(csv.reader(StringIO(response.content.decode(ENCODING))))
         # one header + one context record
         self.assertEqual(len(rows), 2)
         row_cr = rows[1]
@@ -381,12 +383,12 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         response = c.get(reverse('show-contextrecord', kwargs={'pk': obj.pk}))
         self.assertEqual(response.status_code, 200)
         # empty content when not allowed
-        self.assertEqual(response.content, "")
+        self.assertEqual(response.content, b"")
 
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('show-contextrecord', kwargs={'pk': obj.pk}))
         self.assertEqual(response.status_code, 200)
-        self.assertIn('class="card sheet"', response.content)
+        self.assertIn(b'class="card sheet"', response.content)
 
     def test_redundant_dating_clean(self):
         obj = self.context_records[0]
@@ -440,49 +442,63 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         child_town = self.create_towns(datas=data)[-1]
         base_town.children.add(child_town)
 
+        town_key = pgettext_lazy("key for text search", u"town")
+
         # simple search
-        search = {'town': base_town.cached_label}
+        search = {town_key: base_town.cached_label}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 1)
 
         # parent search
-        search = {'town': parent_town.cached_label}
+        search = {town_key: parent_town.cached_label}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 1)
 
         # child search
-        search = {'town': child_town.cached_label}
+        search = {town_key: child_town.cached_label}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 1)
 
     def test_search_export(self):
         c = Client()
         response = c.get(reverse('get-contextrecord'))
         # no result when no authentification
-        self.assertTrue(not json.loads(response.content))
+        self.assertTrue(not json.loads(response.content.decode()))
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-contextrecord'))
-        self.assertTrue(json.loads(response.content)['recordsTotal'] == 2)
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 2)
         # test search label
-        response = c.get(reverse('get-contextrecord'),
-                         {'label': 'cr 1'})
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        response = c.get(reverse('get-contextrecord'), {'label': 'cr 1'})
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 1)
         # test search between relations
-        response = c.get(reverse('get-contextrecord'),
-                         {'label': 'cr 1',
-                          'record-relation-type': self.cr_rel_type.label})
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
+        rel_rec_key = pgettext_lazy("key for text search",
+                                    "record-relation-type")
+        response = c.get(
+            reverse('get-contextrecord'),
+            {'search_vector': 'label="cr 1" {}="{}"'.format(
+                rel_rec_key, self.cr_rel_type.label)
+            }
+        )
+        self.assertEqual(
+            json.loads(response.content.decode())['recordsTotal'], 2)
         # test search vector
         response = c.get(reverse('get-contextrecord'),
                          {'search_vector': 'CR'})
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
+        self.assertEqual(json.loads(response.content.decode())['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)['recordsTotal'], 2)
+        self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
+                         2)
         # test search between related operations
         first_ope = self.operations[0]
         first_ope.year = 2010
@@ -502,15 +518,20 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
             left_record=other_ope,
             right_record=first_ope,
             relation_type=rel_ope)
+        rel_key = pgettext_lazy("key for text search",
+                                u"operation-relation-type")
         response = c.get(reverse('get-contextrecord'),
                          {'operation__year': 2010,
-                          'operation-relation-type': rel_ope.label})
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 2)
+                          rel_key: rel_ope.label})
+        self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
+                         2)
         # export
         response = c.get(reverse('get-contextrecord-full',
                                  kwargs={'type': 'csv'}), {'submited': '1'})
+        ENCODING = settings.ENCODING or 'utf-8'
+        content = response.content.decode(ENCODING)
         # 2 lines + header
-        lines = [line for line in response.content.split('\n') if line]
+        lines = [line for line in content.split('\n') if line]
         self.assertEqual(len(lines), 3)
 
     def testUnitHierarchicSearch(self):
@@ -529,28 +550,30 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         # no result when no authentication
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(not json.loads(response.content))
+        content = response.content.decode()
+        self.assertTrue(not json.loads(content))
 
         # one result for exact search
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        res = json.loads(response.content)
-        self.assertTrue(res['recordsTotal'] == 1)
-        self.assertEqual(res["rows"][0]["unit"],
-                         unicode(neg))
+        res = json.loads(response.content.decode())
+        self.assertEqual(res['recordsTotal'], 1)
+        self.assertEqual(res["rows"][0]["unit"], str(neg))
 
         # no result for the brother
         search = {'unit': dest.pk}
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 0)
+        content = response.content.decode()
+        self.assertEqual(json.loads(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)['recordsTotal'], 1)
+        content = response.content.decode()
+        self.assertEqual(json.loads(content)['recordsTotal'], 1)
 
     def testPeriodHierarchicSearch(self):
         cr = self.context_records[0]
@@ -569,26 +592,29 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase):
         # no result when no authentication
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(not json.loads(response.content))
+        content = response.content.decode()
+        self.assertTrue(not json.loads(content))
 
         # one result for exact search
         c.login(username=self.username, password=self.password)
         response = c.get(reverse('get-contextrecord'), search)
         self.assertEqual(response.status_code, 200)
-        res = json.loads(response.content)
+        res = json.loads(response.content.decode())
         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)['recordsTotal'], 0)
+        content = response.content.decode()
+        self.assertEqual(json.loads(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)['recordsTotal'], 1)
+        content = response.content.decode()
+        self.assertEqual(json.loads(content)['recordsTotal'], 1)
 
 
 class ContextRecordPermissionTest(ContextRecordInit, TestCase):
@@ -634,23 +660,25 @@ class ContextRecordPermissionTest(ContextRecordInit, TestCase):
         # no result when no authentification
         c = Client()
         response = c.get(reverse('get-contextrecord'))
-        self.assertTrue(not json.loads(response.content))
+        self.assertTrue(not json.loads(response.content.decode()))
 
         # possession
         c = Client()
         c.login(username=self.alt_username, password=self.alt_password)
         response = c.get(reverse('get-contextrecord'))
         # only one "own" context record available
-        self.assertTrue(json.loads(response.content))
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        content = response.content.decode()
+        self.assertTrue(json.loads(content))
+        self.assertEqual(json.loads(content)['recordsTotal'], 1)
 
         # area filter
         c = Client()
         c.login(username=self.alt_username2, password=self.alt_password2)
         response = c.get(reverse('get-contextrecord'))
         # only one "own" operation available
-        self.assertTrue(json.loads(response.content))
-        self.assertEqual(json.loads(response.content)['recordsTotal'], 1)
+        content = response.content.decode()
+        self.assertTrue(json.loads(content))
+        self.assertEqual(json.loads(content)['recordsTotal'], 1)
 
     def test_own_modify(self):
         # no result when no authentification