Browse Source

Applying pylint styling fix to files

ayush.goyal 5 years ago
parent
commit
8041227b48

+ 1 - 1
apps/filebrowser/src/filebrowser/settings.py

@@ -31,5 +31,5 @@ PERMISSION_ACTIONS = (
   (PERMISSION_ACTION_S3, "Access to S3 from filebrowser and filepicker."),
   (PERMISSION_ACTION_ADLS, "Access to ADLS from filebrowser and filepicker."),
   (PERMISSION_ACTION_ABFS, "Access to ABFS from filebrowser and filepicker."),
-  (PERMISSION_ACTION_GS,  "Access to GS from filebrowser and filepicker.")
+  (PERMISSION_ACTION_GS, "Access to GS from filebrowser and filepicker.")
 )

File diff suppressed because it is too large
+ 69 - 14
apps/jobbrowser/src/jobbrowser/tests.py


+ 2 - 2
apps/jobsub/src/jobsub/settings.py

@@ -13,12 +13,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-DJANGO_APPS=['jobsub']
+DJANGO_APPS = ['jobsub']
 NICE_NAME = "Job Designer"
 REQUIRES_HADOOP = True
 IS_URL_NAMESPACED = True
 
-MIDDLEWARE_CLASSES=[]
+MIDDLEWARE_CLASSES = []
 
 ICON = "jobsub/art/icon_jobsub_48.png"
 MENU_INDEX = 40

+ 49 - 23
apps/jobsub/src/jobsub/tests.py

@@ -48,7 +48,7 @@ class TestJobsubWithHadoop(OozieServerProvider):
     # Ensure access to MR folder.
     # Need to chmod because jobs are submitted as a
     # different user than what was previously used.
-    for i in range(0,10):
+    for i in range(0, 10):
       try:
         self.cluster.fs.do_as_superuser(self.cluster.fs.chmod, '/tmp', 0o777, recursive=True)
         break
@@ -64,17 +64,30 @@ class TestJobsubWithHadoop(OozieServerProvider):
     Workflow.objects.all().delete()
 
   def create_design(self):
-    response = self.client.post(reverse('jobsub:jobsub.views.new_design',
-      kwargs={'node_type': 'mapreduce'}),
-      data={'name': 'sleep_job',
-            'description': '',
-            'node_type': 'mapreduce',
-            'jar_path': '/user/hue/oozie/workspaces/lib/hadoop-examples.jar',
-            'prepares': '[]',
-            'files': '[]',
-            'archives': '[]',
-            'job_properties': '[{\"name\":\"mapred.reduce.tasks\",\"value\":\"1\"},{\"name\":\"mapred.mapper.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.reducer.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.mapoutput.key.class\",\"value\":\"org.apache.hadoop.io.IntWritable\"},{\"name\":\"mapred.mapoutput.value.class\",\"value\":\"org.apache.hadoop.io.NullWritable\"},{\"name\":\"mapred.output.format.class\",\"value\":\"org.apache.hadoop.mapred.lib.NullOutputFormat\"},{\"name\":\"mapred.input.format.class\",\"value\":\"org.apache.hadoop.examples.SleepJob$SleepInputFormat\"},{\"name\":\"mapred.partitioner.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.speculative.execution\",\"value\":\"false\"},{\"name\":\"sleep.job.map.sleep.time\",\"value\":\"0\"},{\"name\":\"sleep.job.reduce.sleep.time\",\"value\":\"${REDUCER_SLEEP_TIME}\"}]'},
-      HTTP_X_REQUESTED_WITH='XMLHttpRequest')
+    response = self.client.post(
+      reverse('jobsub:jobsub.views.new_design', kwargs={'node_type': 'mapreduce'}),
+      data={
+        'name': 'sleep_job',
+        'description': '',
+        'node_type': 'mapreduce',
+        'jar_path': '/user/hue/oozie/workspaces/lib/hadoop-examples.jar',
+        'prepares': '[]',
+        'files': '[]',
+        'archives': '[]',
+        'job_properties': ('[{\"name\":\"mapred.reduce.tasks\",\"value\":\"1\"},'
+          '{\"name\":\"mapred.mapper.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.reducer.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.mapoutput.key.class\",\"value\":\"org.apache.hadoop.io.IntWritable\"},'
+          '{\"name\":\"mapred.mapoutput.value.class\",\"value\":\"org.apache.hadoop.io.NullWritable\"},'
+          '{\"name\":\"mapred.output.format.class\",\"value\":\"org.apache.hadoop.mapred.lib.NullOutputFormat\"},'
+          '{\"name\":\"mapred.input.format.class\",\"value\":\"org.apache.hadoop.examples.SleepJob$SleepInputFormat\"},'
+          '{\"name\":\"mapred.partitioner.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.speculative.execution\",\"value\":\"false\"},'
+          '{\"name\":\"sleep.job.map.sleep.time\",\"value\":\"0\"},'
+          '{\"name\":\"sleep.job.reduce.sleep.time\",\"value\":\"${REDUCER_SLEEP_TIME}\"}]')
+      },
+      HTTP_X_REQUESTED_WITH='XMLHttpRequest'
+    )
     assert_equal(response.status_code, 200)
     return Workflow.objects.all()[0]
 
@@ -92,17 +105,30 @@ class TestJobsubWithHadoop(OozieServerProvider):
     assert_equal(3, Link.objects.filter(parent__workflow=self.design).count())
 
   def test_save_design(self):
-    response = self.client.post(reverse('jobsub:jobsub.views.save_design',
-      kwargs={'design_id': self.design.id}),
-      data={'name': 'mapreduce1',
-            'description': '',
-            'node_type': 'mapreduce',
-            'jar_path': '/user/hue/oozie/workspaces/lib/hadoop-examples.jar',
-            'prepares': '[]',
-            'files': '[{"name": "test", "dummy": ""}]',
-            'archives': '[]',
-            'job_properties': '[{\"name\":\"mapred.reduce.tasks\",\"value\":\"1\"},{\"name\":\"mapred.mapper.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.reducer.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.mapoutput.key.class\",\"value\":\"org.apache.hadoop.io.IntWritable\"},{\"name\":\"mapred.mapoutput.value.class\",\"value\":\"org.apache.hadoop.io.NullWritable\"},{\"name\":\"mapred.output.format.class\",\"value\":\"org.apache.hadoop.mapred.lib.NullOutputFormat\"},{\"name\":\"mapred.input.format.class\",\"value\":\"org.apache.hadoop.examples.SleepJob$SleepInputFormat\"},{\"name\":\"mapred.partitioner.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},{\"name\":\"mapred.speculative.execution\",\"value\":\"false\"},{\"name\":\"sleep.job.map.sleep.time\",\"value\":\"0\"},{\"name\":\"sleep.job.reduce.sleep.time\",\"value\":\"${REDUCER_SLEEP_TIME}\"}]'},
-      HTTP_X_REQUESTED_WITH='XMLHttpRequest')
+    response = self.client.post(
+      reverse('jobsub:jobsub.views.save_design', kwargs={'design_id': self.design.id}),
+      data={
+        'name': 'mapreduce1',
+        'description': '',
+        'node_type': 'mapreduce',
+        'jar_path': '/user/hue/oozie/workspaces/lib/hadoop-examples.jar',
+        'prepares': '[]',
+        'files': '[{"name": "test", "dummy": ""}]',
+        'archives': '[]',
+        'job_properties': ('[{\"name\":\"mapred.reduce.tasks\",\"value\":\"1\"},'
+          '{\"name\":\"mapred.mapper.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.reducer.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.mapoutput.key.class\",\"value\":\"org.apache.hadoop.io.IntWritable\"},'
+          '{\"name\":\"mapred.mapoutput.value.class\",\"value\":\"org.apache.hadoop.io.NullWritable\"},'
+          '{\"name\":\"mapred.output.format.class\",\"value\":\"org.apache.hadoop.mapred.lib.NullOutputFormat\"},'
+          '{\"name\":\"mapred.input.format.class\",\"value\":\"org.apache.hadoop.examples.SleepJob$SleepInputFormat\"},'
+          '{\"name\":\"mapred.partitioner.class\",\"value\":\"org.apache.hadoop.examples.SleepJob\"},'
+          '{\"name\":\"mapred.speculative.execution\",\"value\":\"false\"},'
+          '{\"name\":\"sleep.job.map.sleep.time\",\"value\":\"0\"},'
+          '{\"name\":\"sleep.job.reduce.sleep.time\",\"value\":\"${REDUCER_SLEEP_TIME}\"}]')
+      },
+      HTTP_X_REQUESTED_WITH='XMLHttpRequest'
+    )
     assert_equal(response.status_code, 200)
     self.design = Workflow.objects.get(id=self.design.id)
     assert_equal(self.design.start.get_child('to').get_full_node().files, '[{"dummy": "", "name": "test"}]')

+ 69 - 17
apps/metastore/src/metastore/tests.py

@@ -79,7 +79,7 @@ class TestApi():
   def test_show_tables(self):
     grant_access("test", "default", "metastore")
     with patch('beeswax.server.dbms.get') as get:
-      get.return_value=Mock(
+      get.return_value = Mock(
         get_databases=Mock(
           return_value=['sfdc']
         ),
@@ -272,9 +272,16 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     assert_true("baz_drop" in [part['columns'][0] for part in data['partition_values_json']], data)
 
     # Drop partition
-    self.client.post("/metastore/table/%s/test_partitions/partitions/drop" % self.db_name, {'partition_selection': [partition_spec]}, follow=True)
+    self.client.post(
+      "/metastore/table/%s/test_partitions/partitions/drop" % self.db_name,
+      {'partition_selection': [partition_spec]},
+      follow=True
+    )
     query = QueryHistory.objects.latest('id')
-    assert_equal_mod_whitespace("ALTER TABLE `%s`.`test_partitions` DROP IF EXISTS PARTITION (%s) PURGE" % (self.db_name, partition_spec), query.query)
+    assert_equal_mod_whitespace(
+      "ALTER TABLE `%s`.`test_partitions` DROP IF EXISTS PARTITION (%s) PURGE" % (self.db_name, partition_spec),
+      query.query
+    )
     response = self.client.get("/metastore/table/%s/test_partitions/partitions" % self.db_name, {'format': 'json'})
     data = json.loads(response.content)
     assert_false("baz_drop" in [part['columns'][0] for part in data['partition_values_json']], data)
@@ -291,7 +298,10 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     # Drop them
     resp = self.client.get('/metastore/tables/drop/%s' % self.db_name, follow=True)
     assert_true('want to delete' in resp.content, resp.content)
-    resp = self.client.post('/metastore/tables/drop/%s' % self.db_name, {u'table_selection': [u'test_drop_1', u'test_drop_2', u'test_drop_3'], 'is_embeddable': True})
+    resp = self.client.post(
+      '/metastore/tables/drop/%s' % self.db_name,
+      {u'table_selection': [u'test_drop_1', u'test_drop_2', u'test_drop_3'], 'is_embeddable': True}
+    )
     assert_equal(resp.status_code, 302)
 
   def test_drop_multi_tables_with_skip_trash(self):
@@ -306,7 +316,15 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     # Drop them
     resp = self.client.get('/metastore/tables/drop/%s' % self.db_name, follow=True)
     assert_true('want to delete' in resp.content, resp.content)
-    resp = self.client.post('/metastore/tables/drop/%s' % self.db_name, {u'table_selection': [u'test_drop_multi_tables_with_skip_trash_1', u'test_drop_multi_tables_with_skip_trash_2', u'test_drop_multi_tables_with_skip_trash_3'], u'skip_trash': u'on', 'is_embeddable': True})
+    resp = self.client.post(
+      '/metastore/tables/drop/%s' % self.db_name,
+      {
+        u'table_selection': [u'test_drop_multi_tables_with_skip_trash_1',
+          u'test_drop_multi_tables_with_skip_trash_2', u'test_drop_multi_tables_with_skip_trash_3'],
+        u'skip_trash': u'on',
+        'is_embeddable': True
+      }
+    )
     assert_equal(resp.status_code, 302)
 
     response = self.client.get("/metastore/tables/%s?format=json" % self.db_name)
@@ -368,16 +386,29 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     data = json.loads(response.content)
     query = QueryHistory.objects.get(id=data['query_history_id'])
 
-    assert_equal_mod_whitespace("LOAD DATA INPATH '%(data_path)s' OVERWRITE INTO TABLE `%(db)s`.`test`" % {'data_path': data_path, 'db': self.db_name}, query.query)
+    assert_equal_mod_whitespace(
+      "LOAD DATA INPATH '%(data_path)s' OVERWRITE INTO TABLE `%(db)s`.`test`" % {'data_path': data_path, 'db': self.db_name}, query.query
+    )
 
     resp = self.client.post("/metastore/table/%s/test/load" % self.db_name, {'path': data_path, 'overwrite': False}, follow=True)
     query = QueryHistory.objects.latest('id')
-    assert_equal_mod_whitespace("LOAD DATA INPATH '%(data_path)s' INTO TABLE `%(db)s`.`test`" % {'data_path': data_path, 'db': self.db_name}, query.query)
+    assert_equal_mod_whitespace(
+      "LOAD DATA INPATH '%(data_path)s' INTO TABLE `%(db)s`.`test`" % {'data_path': data_path, 'db': self.db_name}, query.query
+    )
 
     # Try it with partitions
-    resp = self.client.post("/metastore/table/%s/test_partitions/load" % self.db_name, {'path': data_path, 'partition_0': "alpha", 'partition_1': 12345}, follow=True)
+    resp = self.client.post(
+      "/metastore/table/%s/test_partitions/load" % self.db_name,
+      {'path': data_path, 'partition_0': "alpha", 'partition_1': 12345},
+      follow=True
+    )
     query = QueryHistory.objects.latest('id')
-    assert_equal_mod_whitespace(query.query, "LOAD DATA INPATH '%(data_path)s' INTO TABLE `%(db)s`.`test_partitions` PARTITION (baz='alpha', boom='12345')" % {'data_path': data_path, 'db': self.db_name})
+    assert_equal_mod_whitespace(
+      query.query,
+      "LOAD DATA INPATH '%(data_path)s' INTO TABLE `%(db)s`.`test_partitions` PARTITION (baz='alpha', boom='12345')" % {
+        'data_path': data_path, 'db': self.db_name
+      }
+    )
 
 
   def test_has_write_access_frontend(self):
@@ -410,7 +441,8 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     grant_access("write_access_backend", "write_access_backend", "beeswax")
     user = User.objects.get(username='write_access_backend')
 
-    resp = _make_query(client, 'CREATE TABLE test_perm_1 (a int);', database=self.db_name) # Only fails if we were using Sentry and won't allow SELECT to user
+    # Only fails if we were using Sentry and won't allow SELECT to user
+    resp = _make_query(client, 'CREATE TABLE test_perm_1 (a int);', database=self.db_name)
     resp = wait_for_query_to_finish(client, resp, max=30.0)
 
     def check(client, http_codes):
@@ -485,9 +517,10 @@ class TestMetastoreWithHadoop(BeeswaxSampleProvider):
     assert_true('int', resp.content)
 
     # Alter name, type and comment
-    resp = self.client.post(reverse("metastore:alter_column",
-                                    kwargs={'database': self.db_name, 'table': 'test_alter_column'}),
-                            {'column': 'before_alter', 'new_column_name': 'after_alter', 'new_column_type': 'string', 'comment': 'alter comment'})
+    resp = self.client.post(
+      reverse("metastore:alter_column", kwargs={'database': self.db_name, 'table': 'test_alter_column'}),
+      {'column': 'before_alter', 'new_column_name': 'after_alter', 'new_column_type': 'string', 'comment': 'alter comment'}
+    )
     json_resp = json.loads(resp.content)
     assert_equal('after_alter', json_resp['data']['name'], json_resp)
     assert_equal('string', json_resp['data']['type'], json_resp)
@@ -553,7 +586,10 @@ class TestParser(object):
     name = 'struct'
     type = 'struct<name:string,age:int>'
     comment = 'test_parse_struct'
-    column = {'name': name, 'type': 'struct', 'comment': comment, 'fields': [{'name': 'name', 'type': 'string'}, {'name': 'age', 'type': 'int'}]}
+    column = {
+      'name': name, 'type': 'struct', 'comment': comment,
+      'fields': [{'name': 'name', 'type': 'string'}, {'name': 'age', 'type': 'int'}]
+    }
     parse_tree = parser.parse_column(name, type, comment)
     assert_equal(parse_tree, column)
 
@@ -562,14 +598,30 @@ class TestParser(object):
     name = 'nested'
     type = 'array<struct<name:string,age:int>>'
     comment = 'test_parse_nested'
-    column = {'name': name, 'type': 'array', 'comment': comment, 'item': {'type': 'struct', 'fields': [{'name': 'name', 'type': 'string'}, {'name': 'age', 'type': 'int'}]}}
+    column = {
+      'name': name, 'type': 'array', 'comment': comment,
+      'item': {'type': 'struct', 'fields': [{'name': 'name', 'type': 'string'}, {'name': 'age', 'type': 'int'}]}
+    }
     parse_tree = parser.parse_column(name, type, comment)
     assert_equal(parse_tree, column)
 
   def test_parse_nested_with_array(self):
     name = 'nested'
-    type = 'struct<fieldname1:bigint,fieldname2:int,fieldname3:int,fieldname4:array<bigint>,fieldname5:bigint,fieldname6:array<struct<array_elem:string>>,fieldname7:string>'
+    type = ('struct<fieldname1:bigint,fieldname2:int,fieldname3:int,fieldname4:array<bigint>,'
+      'fieldname5:bigint,fieldname6:array<struct<array_elem:string>>,fieldname7:string>')
     comment = 'test_parse_nested'
-    column = {'comment': 'test_parse_nested', 'fields': [{'type': 'bigint', 'name': 'fieldname1'}, {'type': 'int', 'name': 'fieldname2'}, {'type': 'int', 'name': 'fieldname3'}, {'item': {'type': 'bigint'}, 'type': 'array', 'name': 'fieldname4'}, {'type': 'bigint', 'name': 'fieldname5'}, {'item': {'fields': [{'type': 'string', 'name': 'array_elem'}], 'type': 'struct'}, 'type': 'array', 'name': 'fieldname6'}, {'type': 'string', 'name': 'fieldname7'}], 'type': 'struct', 'name': 'nested'}
+    column = {
+      'comment': 'test_parse_nested',
+      'fields': [
+        {'type': 'bigint', 'name': 'fieldname1'},
+        {'type': 'int', 'name': 'fieldname2'},
+        {'type': 'int', 'name': 'fieldname3'},
+        {'item': {'type': 'bigint'}, 'type': 'array', 'name': 'fieldname4'},
+        {'type': 'bigint', 'name': 'fieldname5'},
+        {'item': {'fields': [{'type': 'string', 'name': 'array_elem'}], 'type': 'struct'}, 'type': 'array', 'name': 'fieldname6'},
+        {'type': 'string', 'name': 'fieldname7'}
+      ],
+      'type': 'struct', 'name': 'nested'
+    }
     parse_tree = parser.parse_column(name, type, comment)
     assert_equal(parse_tree, column)

+ 1 - 1
apps/proxy/src/proxy/settings.py

@@ -13,7 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-DJANGO_APPS = [ "proxy" ]
+DJANGO_APPS = ["proxy"]
 NICE_NAME = "Proxy"
 REQUIRES_HADOOP = False
 IS_URL_NAMESPACED = True

+ 1 - 1
apps/useradmin/src/useradmin/settings.py

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-DJANGO_APPS = [ "useradmin" ]
+DJANGO_APPS = ["useradmin"]
 NICE_NAME = "User Admin"
 REQUIRES_HADOOP = False
 ICON = "useradmin/art/icon_useradmin_48.png"

+ 123 - 50
apps/useradmin/src/useradmin/test_ldap.py

@@ -55,8 +55,10 @@ class TestUserAdminLdap(BaseUserAdminTests):
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
     # Make sure LDAP groups exist or they won't sync
-    import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
-    import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+    import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+      import_members_recursive=False, sync_users=False, import_by_dn=False)
+    import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+      import_members_recursive=False, sync_users=False, import_by_dn=False)
 
     reset = []
 
@@ -120,19 +122,22 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 3)
       assert_equal(Group.objects.all().count(), 2)
       test_admins = Group.objects.get(name='Test Administrators')
@@ -142,18 +147,21 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 3)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 1)
 
       # Import all members of TestUsers and members of subgroups
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 4)
@@ -163,7 +171,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -186,19 +195,22 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 3)
       assert_equal(Group.objects.all().count(), 2)
       test_admins = Group.objects.get(name='Test Administrators')
@@ -209,25 +221,29 @@ class TestUserAdminLdap(BaseUserAdminTests):
       # Only sync already imported
       assert_equal(test_users.user_set.all().count(), 3)
       ldap_access.CACHED_LDAP_CONN.remove_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 3)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 1)
 
       # Import all members of TestUsers and not members of suboordinate groups (even though specified)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Nested group import
       # First without recursive import, then with.
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       nested_groups = Group.objects.get(name='NestedGroups')
       nested_group = Group.objects.get(name='NestedGroup')
       assert_true(LdapGroup.objects.filter(group=nested_groups).exists())
@@ -235,7 +251,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       assert_equal(nested_groups.user_set.all().count(), 0, nested_groups.user_set.all())
       assert_equal(nested_group.user_set.all().count(), 0, nested_group.user_set.all())
 
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       nested_groups = Group.objects.get(name='NestedGroups')
       nested_group = Group.objects.get(name='NestedGroup')
       assert_true(LdapGroup.objects.filter(group=nested_groups).exists())
@@ -248,7 +265,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -271,19 +289,22 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 2, User.objects.all())
       assert_equal(Group.objects.all().count(), 2, Group.objects.all())
       test_admins = Group.objects.get(name='Test Administrators')
@@ -293,18 +314,21 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 1)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 1)
 
       # Import all members of PosixGroup and members of subgroups
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
@@ -314,7 +338,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -337,19 +362,22 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 2, User.objects.all())
       assert_equal(Group.objects.all().count(), 2, Group.objects.all())
       test_admins = Group.objects.get(name='Test Administrators')
@@ -359,18 +387,21 @@ class TestUserAdminLdap(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 1)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 1)
 
       # Import all members of PosixGroup and members of subgroups (there should be no subgroups)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
@@ -379,7 +410,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       reset_all_users()
       reset_all_groups()
 
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedPosixGroups', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedPosixGroups', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='NestedPosixGroups')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
@@ -392,7 +424,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -438,8 +471,10 @@ class TestUserAdminLdap(BaseUserAdminTests):
       assert_equal(hue_user.first_name, 'Different')
 
       # Make sure LDAP groups exist or they won't sync
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       # Try importing a user and sync groups
       import_ldap_users(ldap_access.CACHED_LDAP_CONN, 'curly', sync_groups=True, import_by_dn=False, server='multi_ldap_conf')
       curly = User.objects.get(username='curly')
@@ -519,7 +554,7 @@ class TestUserAdminLdap(BaseUserAdminTests):
     done.append(desktop.conf.LDAP.LDAP_SERVERS.set_for_testing(get_multi_ldap_config()))
 
     try:
-      URL = reverse(add_ldap_users)
+      URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
       # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
       ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -566,7 +601,11 @@ class TestUserAdminLdap(BaseUserAdminTests):
       assert_true("Username must not contain whitespaces and ':'" in response.context[0]['form'].errors['username_pattern'][0], response)
 
       # Test dn with spaces in username and dn (should fail)
-      response = c.post(URL, dict(server='multi_ldap_conf', username_pattern='uid=user with space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True))
+      response = c.post(
+        URL,
+        dict(server='multi_ldap_conf', username_pattern='uid=user with space,ou=People,dc=example,dc=com',
+          password1='test', password2='test', dn=True)
+        )
       assert_true(b"Could not get LDAP details for users in pattern" in response.content, response.content)
       response = c.get(reverse(desktop.views.log_view))
       whitespaces_message = "{username}: Username must not contain whitespaces".format(username='user with space')
@@ -575,7 +614,11 @@ class TestUserAdminLdap(BaseUserAdminTests):
       assert_true(whitespaces_message in response.content, response.content)
 
       # Test dn with spaces in dn, but not username (should succeed)
-      response = c.post(URL, dict(server='multi_ldap_conf', username_pattern='uid=user without space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True))
+      response = c.post(
+        URL,
+        dict(server='multi_ldap_conf', username_pattern='uid=user without space,ou=People,dc=example,dc=com',
+          password1='test', password2='test', dn=True)
+        )
       assert_true(User.objects.filter(username='spaceless').exists())
 
     finally:
@@ -594,7 +637,7 @@ class TestUserAdminLdap(BaseUserAdminTests):
     done.append(desktop.conf.LDAP.LDAP_SERVERS.set_for_testing(get_multi_ldap_config()))
 
     try:
-      URL = reverse(add_ldap_users)
+      URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
       # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
       ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -621,7 +664,16 @@ class TestUserAdminLdap(BaseUserAdminTests):
         finish()
 
   def test_ldap_import_truncate_first_last_name(self):
-    test_ldap_data = [('uid=testuser,ou=people,dc=sec,dc=test,dc=com', {'objectClass': ['inetOrgPerson', 'posixAccount', 'shadowAccount'], 'mail': ['testuser@sec.test.com'], 'givenName': ['Firstnamehasmorethanthirtycharacters'], 'uid': ['testuser'], 'sn': ['Lastnamehasmorethanthirtycharacters']})]
+    test_ldap_data = [(
+      'uid=testuser,ou=people,dc=sec,dc=test,dc=com',
+      {
+        'objectClass': ['inetOrgPerson', 'posixAccount', 'shadowAccount'],
+        'mail': ['testuser@sec.test.com'],
+        'givenName': ['Firstnamehasmorethanthirtycharacters'],
+        'uid': ['testuser'],
+        'sn': ['Lastnamehasmorethanthirtycharacters']
+      }
+    )]
 
     # Checking if first/last name truncation works for LDAP imports
     user_info = ldap_access.LdapConnection._transform_find_user_results(result_data=test_ldap_data, user_name_attr='uid')
@@ -630,7 +682,16 @@ class TestUserAdminLdap(BaseUserAdminTests):
     assert_true(user_info[0]['first'] == 'Firstnamehasmorethanthirtychar', user_info[0]['first'])
     assert_true(user_info[0]['last'] == 'Lastnamehasmorethanthirtychara', user_info[0]['last'])
 
-    test_ldap_data = [('uid=thaiuser,ou=people,dc=sec,dc=test,dc=com', {'objectClass': ['inetOrgPerson', 'posixAccount', 'shadowAccount'], 'mail': ['thaiuser@sec.test.com'], 'givenName': ['ดีหรือแย่ อย่าไปแคร์ คนนินทา'], 'uid': ['thaiuser'], 'sn': ['ชมหรือด่า อย่าไปรับ ให้กลับคืนไป']})]
+    test_ldap_data = [(
+      'uid=thaiuser,ou=people,dc=sec,dc=test,dc=com',
+      {
+        'objectClass': ['inetOrgPerson', 'posixAccount', 'shadowAccount'],
+        'mail': ['thaiuser@sec.test.com'],
+        'givenName': ['ดีหรือแย่ อย่าไปแคร์ คนนินทา'],
+        'uid': ['thaiuser'],
+        'sn': ['ชมหรือด่า อย่าไปรับ ให้กลับคืนไป']
+      }
+    )]
 
     # Checking if first/last name in Thai truncation works for LDAP imports
     user_info = ldap_access.LdapConnection._transform_find_user_results(result_data=test_ldap_data, user_name_attr='uid')
@@ -653,7 +714,7 @@ class TestUserAdminLdap(BaseUserAdminTests):
     assert_true(user.last_name, truncated_last_name)
 
   def test_add_ldap_groups(self):
-    URL = reverse(add_ldap_groups)
+    URL = reverse('useradmin:useradmin.views.add_ldap_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -685,7 +746,8 @@ class TestUserAdminLdap(BaseUserAdminTests):
         user_list_a = create_long_username() + b", test_longfirstname"
         user_list_b = b"test_longfirstname, " + create_long_username()
 
-      assert_true(b'Failed to import following users: %s' % user_list_a in response.content or b'Failed to import following users: %s' % user_list_b in response.content, response.content)
+      assert_true(b'Failed to import following users: %s' % user_list_a in response.content \
+        or b'Failed to import following users: %s' % user_list_b in response.content, response.content)
 
       # Test with space
       response = c.post(URL, dict(server='multi_ldap_conf', groupname_pattern='Test Administrators'))
@@ -708,7 +770,7 @@ class TestUserAdminLdap(BaseUserAdminTests):
         finish()
 
   def test_sync_ldap_users_groups(self):
-    URL = reverse(sync_ldap_users_groups)
+    URL = reverse('useradmin:useradmin_views_sync_ldap_users_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -744,7 +806,11 @@ class TestUserAdminLdap(BaseUserAdminTests):
     reset.append(desktop.conf.LDAP.LDAP_SERVERS.set_for_testing(get_multi_ldap_config()))
 
     try:
-      response = c.post(reverse(add_ldap_users), dict(server='multi_ldap_conf', username_pattern='moe', password1='test', password2='test'), follow=True)
+      response = c.post(
+        reverse('useradmin:useradmin.views.add_ldap_users'),
+        dict(server='multi_ldap_conf', username_pattern='moe', password1='test', password2='test'),
+        follow=True
+      )
       assert_true(b'There was an error when communicating with LDAP' in response.content, response)
     finally:
       for finish in reset:
@@ -756,7 +822,7 @@ class TestUserAdminLdapWithHadoop(BaseUserAdminTests):
   integration = True
 
   def test_ensure_home_directory_add_ldap_users(self):
-    URL = reverse(add_ldap_users)
+    URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -779,7 +845,9 @@ class TestUserAdminLdapWithHadoop(BaseUserAdminTests):
       assert_false(cluster.fs.exists('/user/moe'))
 
       # Try same thing with home directory creation.
-      response = c.post(URL, dict(server='multi_ldap_conf', username_pattern='curly', password1='test', password2='test', ensure_home_directory=True))
+      response = c.post(
+        URL, dict(server='multi_ldap_conf', username_pattern='curly', password1='test', password2='test', ensure_home_directory=True)
+      )
       assert_true('/useradmin/users' in response['Location'])
       assert_true(cluster.fs.exists('/user/curly'))
 
@@ -791,7 +859,9 @@ class TestUserAdminLdapWithHadoop(BaseUserAdminTests):
       assert_false(cluster.fs.exists('/user/moe'))
 
       # Try wild card now
-      response = c.post(URL, dict(server='multi_ldap_conf', username_pattern='*rr*', password1='test', password2='test', ensure_home_directory=True))
+      response = c.post(
+        URL, dict(server='multi_ldap_conf', username_pattern='*rr*', password1='test', password2='test', ensure_home_directory=True)
+      )
       assert_true('/useradmin/users' in response['Location'])
       assert_true(cluster.fs.exists('/user/curly'))
       assert_true(cluster.fs.exists(u'/user/lårry'))
@@ -809,7 +879,7 @@ class TestUserAdminLdapWithHadoop(BaseUserAdminTests):
         cluster.fs.rmtree('/user/otherguy')
 
   def test_ensure_home_directory_sync_ldap_users_groups(self):
-    URL = reverse(sync_ldap_users_groups)
+    URL = reverse('useradmin:useradmin_views_sync_ldap_users_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -825,7 +895,10 @@ class TestUserAdminLdapWithHadoop(BaseUserAdminTests):
     reset.append(desktop.conf.LDAP.LDAP_SERVERS.set_for_testing(get_multi_ldap_config()))
 
     try:
-      c.post(reverse(add_ldap_users), dict(server='multi_ldap_conf', username_pattern='curly', password1='test', password2='test'))
+      c.post(
+        reverse('useradmin:useradmin.views.add_ldap_users'),
+        dict(server='multi_ldap_conf', username_pattern='curly', password1='test', password2='test')
+      )
       assert_false(cluster.fs.exists('/user/curly'))
       assert_true(c.post(URL, dict(server='multi_ldap_conf', ensure_home_directory=True)))
       assert_true(cluster.fs.exists('/user/curly'))

+ 86 - 45
apps/useradmin/src/useradmin/test_ldap_deprecated.py

@@ -46,8 +46,10 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
       ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
       # Make sure LDAP groups exist or they won't sync
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
 
       # Import curly who is part of TestUsers and Test Administrators
       import_ldap_users(ldap_access.CACHED_LDAP_CONN, 'curly', sync_groups=False, import_by_dn=False)
@@ -97,19 +99,22 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 3)
       assert_equal(Group.objects.all().count(), 2)
       test_admins = Group.objects.get(name='Test Administrators')
@@ -119,18 +124,21 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 3)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 1)
 
       # Import all members of TestUsers and members of subgroups
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 4)
@@ -140,7 +148,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -159,19 +168,22 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 3)
       assert_equal(Group.objects.all().count(), 2)
       test_admins = Group.objects.get(name='Test Administrators')
@@ -182,25 +194,29 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       # Only sync already imported
       assert_equal(test_users.user_set.all().count(), 3)
       ldap_access.CACHED_LDAP_CONN.remove_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_user_group_for_test('uid=moe,ou=People,dc=example,dc=com', 'TestUsers')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 3)
       assert_equal(User.objects.get(username='moe').groups.all().count(), 1)
 
       # Import all members of TestUsers and not members of suboordinate groups (even though specified)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='TestUsers')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
 
       # Nested group import
       # First without recursive import, then with.
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       nested_groups = Group.objects.get(name='NestedGroups')
       nested_group = Group.objects.get(name='NestedGroup')
       assert_true(LdapGroup.objects.filter(group=nested_groups).exists())
@@ -208,7 +224,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       assert_equal(nested_groups.user_set.all().count(), 0, nested_groups.user_set.all())
       assert_equal(nested_group.user_set.all().count(), 0, nested_group.user_set.all())
 
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedGroups', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       nested_groups = Group.objects.get(name='NestedGroups')
       nested_group = Group.objects.get(name='NestedGroup')
       assert_true(LdapGroup.objects.filter(group=nested_groups).exists())
@@ -221,7 +238,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -240,19 +258,22 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 2, User.objects.all())
       assert_equal(Group.objects.all().count(), 2, Group.objects.all())
       test_admins = Group.objects.get(name='Test Administrators')
@@ -262,18 +283,21 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 1)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 1)
 
       # Import all members of PosixGroup and members of subgroups
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 3)
@@ -283,7 +307,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -302,19 +327,22 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     try:
       # Import groups only
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
 
       # Import all members of TestUsers
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
 
       # Should import a group, but will only sync already-imported members
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(User.objects.all().count(), 2, User.objects.all())
       assert_equal(Group.objects.all().count(), 2, Group.objects.all())
       test_admins = Group.objects.get(name='Test Administrators')
@@ -324,18 +352,21 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
       # Only sync already imported
       ldap_access.CACHED_LDAP_CONN.remove_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 1)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 0)
 
       # Import missing user
       ldap_access.CACHED_LDAP_CONN.add_posix_user_group_for_test('posix_person', 'PosixGroup')
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_equal(test_users.user_set.all().count(), 2)
       assert_equal(User.objects.get(username='posix_person').groups.all().count(), 1)
 
       # Import all members of PosixGroup and members of subgroups (there should be no subgroups)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'PosixGroup', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='PosixGroup')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 2)
@@ -343,7 +374,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       # Import all members of NestedPosixGroups and members of subgroups
       reset_all_users()
       reset_all_groups()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedPosixGroups', import_members=True, import_members_recursive=True, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'NestedPosixGroups', import_members=True,
+        import_members_recursive=True, sync_users=True, import_by_dn=False)
       test_users = Group.objects.get(name='NestedPosixGroups')
       assert_true(LdapGroup.objects.filter(group=test_users).exists())
       assert_equal(test_users.user_set.all().count(), 0)
@@ -356,7 +388,8 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       hue_group = Group.objects.create(name='OtherGroup')
       hue_group.user_set.add(hue_user)
       hue_group.save()
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False, import_members_recursive=False, sync_users=True, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'OtherGroup', import_members=False,
+        import_members_recursive=False, sync_users=True, import_by_dn=False)
       assert_false(LdapGroup.objects.filter(group=hue_group).exists())
       assert_true(hue_group.user_set.filter(username=hue_user.username).exists())
     finally:
@@ -393,8 +426,10 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       assert_equal(hue_user.first_name, 'Different')
 
       # Make sure LDAP groups exist or they won't sync
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
-      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False, import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'TestUsers', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
+      import_ldap_groups(ldap_access.CACHED_LDAP_CONN, 'Test Administrators', import_members=False,
+        import_members_recursive=False, sync_users=False, import_by_dn=False)
       # Try importing a user and sync groups
       import_ldap_users(ldap_access.CACHED_LDAP_CONN, 'curly', sync_groups=True, import_by_dn=False)
       curly = User.objects.get(username='curly')
@@ -451,7 +486,7 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
   def test_add_ldap_users(self):
     done = []
     try:
-      URL = reverse(add_ldap_users)
+      URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
       # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
       ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -476,7 +511,9 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       assert_true("Username must not contain whitespaces and ':'" in response.context[0]['form'].errors['username_pattern'][0], response)
 
       # Test dn with spaces in username and dn (should fail)
-      response = c.post(URL, dict(username_pattern='uid=user with space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True))
+      response = c.post(
+        URL, dict(username_pattern='uid=user with space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True)
+      )
       assert_true(b"Could not get LDAP details for users in pattern" in response.content, response)
       response = c.get(reverse(desktop.views.log_view))
       whitespaces_message = "{username}: Username must not contain whitespaces".format(username='user with space')
@@ -485,7 +522,9 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
       assert_true(whitespaces_message in response.content, response.content)
 
       # Test dn with spaces in dn, but not username (should succeed)
-      response = c.post(URL, dict(username_pattern='uid=user without space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True))
+      response = c.post(
+        URL, dict(username_pattern='uid=user without space,ou=People,dc=example,dc=com', password1='test', password2='test', dn=True)
+      )
       assert_true(User.objects.filter(username='spaceless').exists())
 
     finally:
@@ -500,7 +539,7 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     done = []
     try:
-      URL = reverse(add_ldap_users)
+      URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
       reset_all_users()
       reset_all_groups()
@@ -537,7 +576,7 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
 
   def test_add_ldap_groups(self):
-    URL = reverse(add_ldap_groups)
+    URL = reverse('useradmin:useradmin.views.add_ldap_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -567,7 +606,7 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
     assert_true('/useradmin/groups' in response['Location'], response)
 
   def test_sync_ldap_users_groups(self):
-    URL = reverse(sync_ldap_users_groups)
+    URL = reverse('useradmin:useradmin_views_sync_ldap_users_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -586,7 +625,9 @@ class TestUserAdminLdapDeprecated(BaseUserAdminTests):
 
     c = make_logged_in_client('test', is_superuser=True)
 
-    response = c.post(reverse(add_ldap_users), dict(username_pattern='moe', password1='test', password2='test'), follow=True)
+    response = c.post(
+      reverse('useradmin:useradmin.views.add_ldap_users'), dict(username_pattern='moe', password1='test', password2='test'), follow=True
+    )
     assert_true(b'There was an error when communicating with LDAP' in response.content, response)
 
 class TestUserAdminLdapDeprecatedWithHadoop(BaseUserAdminTests):
@@ -595,7 +636,7 @@ class TestUserAdminLdapDeprecatedWithHadoop(BaseUserAdminTests):
 
   def test_ensure_home_directory_add_ldap_users(self):
     try:
-      URL = reverse(add_ldap_users)
+      URL = reverse('useradmin:useradmin.views.add_ldap_users')
 
       # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
       ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -638,7 +679,7 @@ class TestUserAdminLdapDeprecatedWithHadoop(BaseUserAdminTests):
         cluster.fs.rmtree('/user/otherguy')
 
   def test_ensure_home_directory_sync_ldap_users_groups(self):
-    URL = reverse(sync_ldap_users_groups)
+    URL = reverse('useradmin:useradmin_views_sync_ldap_users_groups')
 
     # Set up LDAP tests to use a LdapTestConnection instead of an actual LDAP connection
     ldap_access.CACHED_LDAP_CONN = LdapTestConnection()
@@ -647,7 +688,7 @@ class TestUserAdminLdapDeprecatedWithHadoop(BaseUserAdminTests):
     c = make_logged_in_client(cluster.superuser, is_superuser=True)
     cluster.fs.setuser(cluster.superuser)
 
-    c.post(reverse(add_ldap_users), dict(username_pattern='curly', password1='test', password2='test'))
+    c.post(reverse('useradmin:useradmin.views.add_ldap_users'), dict(username_pattern='curly', password1='test', password2='test'))
     assert_false(cluster.fs.exists('/user/curly'))
     assert_true(c.post(URL, dict(ensure_home_directory=True)))
     assert_true(cluster.fs.exists('/user/curly'))

+ 16 - 16
apps/useradmin/src/useradmin/views.py

@@ -237,10 +237,10 @@ def delete_user(request):
   is_embeddable = request.GET.get('is_embeddable', request.POST.get('is_embeddable', False))
 
   if is_embeddable:
-    return JsonResponse({'url': '/hue' + reverse(list_users)})
+    return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_users')})
   else:
     request.info(_('The users were %s.') % action_text)
-    return redirect(reverse(list_users))
+    return redirect(reverse('useradmin:useradmin.views.list_users'))
 
 
 def delete_group(request):
@@ -269,10 +269,10 @@ def delete_group(request):
       is_embeddable = request.GET.get('is_embeddable', request.POST.get('is_embeddable', False))
 
       if is_embeddable:
-        return JsonResponse({'url': '/hue' + reverse(list_groups)})
+        return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_groups')})
       else:
         request.info(_('The groups were deleted.'))
-        return redirect(reverse(list_groups))
+        return redirect(reverse('useradmin:useradmin.views.list_groups'))
     except Group.DoesNotExist:
       raise PopupException(_("Group not found."), error_code=404)
   else:
@@ -403,14 +403,14 @@ def edit_user(request, username=None):
           return JsonResponse({'url': '/hue'})
       elif is_admin(request.user):
         if is_embeddable:
-          return JsonResponse({'url': '/hue' + reverse(list_users)})
+          return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_users')})
         else:
-          return redirect(reverse(list_users))
+          return redirect(reverse('useradmin:useradmin.views.list_users'))
       else:
         if is_embeddable:
-          return JsonResponse({'url': '/hue' + reverse(edit_user, kwargs={'username': username})})
+          return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.edit_user', kwargs={'username': username})})
         else:
-          return redirect(reverse(edit_user, kwargs={'username': username}))
+          return redirect(reverse('useradmin:useradmin.views.edit_user', kwargs={'username': username}))
   else:
     # Initialize form values
     default_user_group = get_default_user_group()
@@ -495,7 +495,7 @@ def edit_group(request, name=None):
         }
 
       if is_embeddable:
-        return JsonResponse({'url': '/hue' + reverse(list_groups)})
+        return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_groups')})
       else:
         request.info(_('Group information updated'))
         return redirect('/useradmin/groups')
@@ -550,10 +550,10 @@ def edit_permission(request, app=None, priv=None):
       }
 
       if is_embeddable:
-        return JsonResponse({'url': '/hue' + reverse(list_permissions)})
+        return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_permissions')})
       else:
         request.info(_('Permission information updated'))
-        return redirect(reverse(list_permissions))
+        return redirect(reverse('useradmin:useradmin.views.list_permissions'))
   else:
     form = PermissionsEditForm(instance=instance)
   if request.method == 'POST' and is_embeddable:
@@ -629,7 +629,7 @@ def add_ldap_users(request):
         if is_embeddable:
           return JsonResponse({'status': 0})
         else:
-          return redirect(reverse(list_users))
+          return redirect(reverse('useradmin:useradmin.views.list_users'))
   else:
     form = AddLdapUsersForm()
 
@@ -705,9 +705,9 @@ def add_ldap_groups(request):
           request.warn(_('Failed to import following users: %s') % ', '.join(unique_users))
 
         if is_embeddable:
-          return JsonResponse({'url': '/hue' + reverse(list_groups)})
+          return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_groups')})
         else:
-          return redirect(reverse(list_groups))
+          return redirect(reverse('useradmin:useradmin.views.list_groups'))
 
       else:
         errors = form._errors.setdefault('groupname_pattern', ErrorList())
@@ -767,9 +767,9 @@ def sync_ldap_users_groups(request):
         request.warn(_('Failed to import following users: %s') % ', '.join(unique_users))
 
       if is_embeddable:
-        return JsonResponse({'url': '/hue' + reverse(list_users)})
+        return JsonResponse({'url': '/hue' + reverse('useradmin:useradmin.views.list_users')})
       else:
-        return redirect(reverse(list_users))
+        return redirect(reverse('useradmin:useradmin.views.list_users'))
   else:
     form = SyncLdapUsersGroupsForm()
 

+ 48 - 48
desktop/core/src/desktop/lib/view_util.py

@@ -43,7 +43,7 @@ def big_filesizeformat(bytes):
   index = int(math.floor(math.log(bytes, 1024)))
   index = min(len(units) - 1, index)
 
-  return( "%.1f %s" % ((bytes / math.pow(1024, index)), units[index]) )
+  return("%.1f %s" % ((bytes / math.pow(1024, index)), units[index]))
 
 def format_time_diff(start=None, end=None):
   """
@@ -69,52 +69,52 @@ def format_time_diff(start=None, end=None):
   return ":".join(output)
 
 def format_duration_in_millis(duration=0):
-    """
-      formats the difference between two times in millis as Xd:Xh:Xm:Xs
-    """
-    seconds, millis = divmod(duration, 1000)
-    minutes, seconds = divmod(seconds, 60)
-    hours, minutes = divmod(minutes, 60)
-    days, hours = divmod(hours, 24)
-    output = []
-    written = False
-    if days:
-        written = True
-        output.append("%dd" % days)
-    if written or hours:
-        written = True
-        output.append("%dh" % hours)
-    if written or minutes:
-        output.append("%dm" % minutes)
-    output.append("%ds" % seconds)
-    return ":".join(output)
+  """
+    formats the difference between two times in millis as Xd:Xh:Xm:Xs
+  """
+  seconds, millis = divmod(duration, 1000)
+  minutes, seconds = divmod(seconds, 60)
+  hours, minutes = divmod(minutes, 60)
+  days, hours = divmod(hours, 24)
+  output = []
+  written = False
+  if days:
+    written = True
+    output.append("%dd" % days)
+  if written or hours:
+    written = True
+    output.append("%dh" % hours)
+  if written or minutes:
+    output.append("%dm" % minutes)
+  output.append("%ds" % seconds)
+  return ":".join(output)
 
 def location_to_url(location, strict=True, is_embeddable=False):
-    """
-    If possible, returns a file browser URL to the location.
-    Prunes HDFS URI to path.
-    Location is a URI, if strict is True.
-
-    Python doesn't seem to have a readily-available URI-comparison
-    library, so this is quite hacky.
-    """
-    if location is None:
-      return None
-    split_path = Hdfs.urlsplit(location)
-    if strict and not split_path[1] or not split_path[2]:
-      # No netloc not full url or no URL
-      return None
-    path = location
-    if split_path[0] == 'hdfs':
-      path = split_path[2]
-
-    try:
-      filebrowser_path = reverse("filebrowser:filebrowser.views.view", kwargs=dict(path=path))
-    except Exception as e:
-      LOG.warn('No table filesystem link: %s' % e)
-      return None
-
-    if is_embeddable and not filebrowser_path.startswith('/hue'):
-        filebrowser_path = '/hue' + filebrowser_path
-
-    return filebrowser_path
+  """
+  If possible, returns a file browser URL to the location.
+  Prunes HDFS URI to path.
+  Location is a URI, if strict is True.
+
+  Python doesn't seem to have a readily-available URI-comparison
+  library, so this is quite hacky.
+  """
+  if location is None:
+    return None
+  split_path = Hdfs.urlsplit(location)
+  if strict and not split_path[1] or not split_path[2]:
+    # No netloc not full url or no URL
+    return None
+  path = location
+  if split_path[0] == 'hdfs':
+    path = split_path[2]
+
+  try:
+    filebrowser_path = reverse("filebrowser:filebrowser.views.view", kwargs=dict(path=path))
+  except Exception as e:
+    LOG.warn('No table filesystem link: %s' % e)
+    return None
+
+  if is_embeddable and not filebrowser_path.startswith('/hue'):
+    filebrowser_path = '/hue' + filebrowser_path
+
+  return filebrowser_path

+ 6 - 2
desktop/libs/liboozie/src/liboozie/types.py

@@ -538,7 +538,9 @@ class Coordinator(Job):
     'total'
   ]
   ACTION = CoordinatorAction
-  RUNNING_STATUSES = set(['PREP', 'RUNNING', 'RUNNINGWITHERROR', 'PREPSUSPENDED', 'SUSPENDED', 'SUSPENDEDWITHERROR', 'PREPPAUSED', 'PAUSED', 'PAUSEDWITHERROR'])
+  RUNNING_STATUSES = set([
+    'PREP', 'RUNNING', 'RUNNINGWITHERROR', 'PREPSUSPENDED', 'SUSPENDED', 'SUSPENDEDWITHERROR', 'PREPPAUSED', 'PAUSED', 'PAUSEDWITHERROR'
+  ])
   FINISHED_STATUSES = set(['SUCCEEDED', 'DONEWITHERROR', 'KILLED', 'FAILED'])
 
   def _fixup(self):
@@ -649,7 +651,9 @@ class Bundle(Job):
   ]
 
   ACTION = BundleAction
-  RUNNING_STATUSES = set(['PREP', 'RUNNING', 'RUNNINGWITHERROR', 'SUSPENDED', 'PREPSUSPENDED', 'SUSPENDEDWITHERROR', 'PAUSED', 'PAUSEDWITHERROR', 'PREPPAUSED'])
+  RUNNING_STATUSES = set([
+    'PREP', 'RUNNING', 'RUNNINGWITHERROR', 'SUSPENDED', 'PREPSUSPENDED', 'SUSPENDEDWITHERROR', 'PAUSED', 'PAUSEDWITHERROR', 'PREPPAUSED'
+  ])
   FINISHED_STATUSES = set(['SUCCEEDED', 'DONEWITHERROR', 'KILLED', 'FAILED'])
 
   def _fixup(self):

+ 3 - 2
desktop/libs/notebook/src/notebook/connectors/dataeng.py

@@ -88,7 +88,7 @@ class DataEngApi(Api):
 
   def fetch_result(self, notebook, snippet, rows, start_over):
     return {
-        'data':  [[_('Job successfully completed.')]],
+        'data': [[_('Job successfully completed.')]],
         'meta': [{'name': 'Header', 'type': 'STRING_TYPE', 'comment': ''}],
         'type': 'table',
         'has_more': False,
@@ -113,7 +113,8 @@ class DataEngApi(Api):
     #    operation_execution_id='cedb71ae-0956-42e1-8578-87b9261d4a37',
     #    attempt_id='attempt_1499705340501_0045_m_000000_0'
     # )
-    # return ''.join(re.findall('(?<=>>> Invoking Beeline command line now >>>)(.*?)(?=<<< Invocation of Beeline command completed <<<)', logs['stdout'], re.DOTALL))
+    # return ''.join(re.findall('(?<=>>> Invoking Beeline command line now >>>)
+    # (.*?)(?=<<< Invocation of Beeline command completed <<<)', logs['stdout'], re.DOTALL))
     return ''
 
 

+ 1 - 1
docs/docs-site/content/releases/release-notes-2.0.0-beta.md

@@ -365,7 +365,7 @@ List of All Commits
 * HUE-633. [jobsub] Port examples to new design models
 * [test] Work around a webhdfs redirect bug in test
 * [doc] document dependency on libldap2-dev
-* HUE-648. [fb] filebrowser:filebrowser.views.view() makes too many filesystem calls
+* HUE-648. [fb] filebrowser.views.view() makes too many filesystem calls
 * HUE-635 Porting to Bootstrap 2
 * HUE-647 changed my home link and breadcrumbs
 * Various fixes: HUE-657, HUE-650, HUE-649, HUE-646, HUE-645, HUE-652, HUE-642 and HUE-643

+ 1 - 1
docs/docs-site/content/releases/release-notes-2.0.1.md

@@ -373,7 +373,7 @@ List of All Commits
 * HUE-633. [jobsub] Port examples to new design models
 * [test] Work around a webhdfs redirect bug in test
 * [doc] document dependency on libldap2-dev
-* HUE-648. [fb] filebrowser:filebrowser.views.view() makes too many filesystem calls
+* HUE-648. [fb] filebrowser.views.view() makes too many filesystem calls
 * HUE-635 Porting to Bootstrap 2
 * HUE-647 changed my home link and breadcrumbs
 * Various fixes: HUE-657, HUE-650, HUE-649, HUE-646, HUE-645, HUE-652, HUE-642 and HUE-643

+ 1 - 1
docs/release-notes/release-notes-2.0.0-beta.txt

@@ -357,7 +357,7 @@ List of All Commits
 * HUE-633. [jobsub] Port examples to new design models
 * [test] Work around a webhdfs redirect bug in test
 * [doc] document dependency on libldap2-dev
-* HUE-648. [fb] filebrowser:filebrowser.views.view() makes too many filesystem calls
+* HUE-648. [fb] filebrowser.views.view() makes too many filesystem calls
 * HUE-635 Porting to Bootstrap 2
 * HUE-647 changed my home link and breadcrumbs
 * Various fixes: HUE-657, HUE-650, HUE-649, HUE-646, HUE-645, HUE-652, HUE-642 and HUE-643

+ 1 - 1
docs/release-notes/release-notes-2.0.1.txt

@@ -365,7 +365,7 @@ List of All Commits
 * HUE-633. [jobsub] Port examples to new design models
 * [test] Work around a webhdfs redirect bug in test
 * [doc] document dependency on libldap2-dev
-* HUE-648. [fb] filebrowser:filebrowser.views.view() makes too many filesystem calls
+* HUE-648. [fb] filebrowser.views.view() makes too many filesystem calls
 * HUE-635 Porting to Bootstrap 2
 * HUE-647 changed my home link and breadcrumbs
 * Various fixes: HUE-657, HUE-650, HUE-649, HUE-646, HUE-645, HUE-652, HUE-642 and HUE-643

Some files were not shown because too many files changed in this diff