Standardize Armada code with YAPF

From recently merged document updates in [0] there is a desire to
standardize the Airship project python codebase.  This is the effort
to do so for the Armada project.

[0] https://review.opendev.org/#/c/671291/

Change-Id: I4fe916d6e330618ea3a1fccfa4bdfdfabb9ffcb2

armada/tests/test_utils.py

@@ -15,14 +15,14 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-
-import mock
 import random
 import string
-import testtools
 import threading
 import uuid
 
+import mock
+import testtools
+
 _mock_thread_safe = False
 _mock_call_lock = threading.RLock()
 

armada/tests/unit/api/base.py

@@ -32,8 +32,9 @@ class BaseControllerTest(test_base.ArmadaTestCase):
         # the sample configuration files to avoid oslo.conf errors when
         # creating the server below.
         current_dir = os.path.dirname(os.path.realpath(__file__))
-        sample_conf_dir = os.path.join(current_dir, os.pardir, os.pardir,
-                                       os.pardir, os.pardir, 'etc', 'armada')
+        sample_conf_dir = os.path.join(
+            current_dir, os.pardir, os.pardir, os.pardir, os.pardir, 'etc',
+            'armada')
         sample_conf_files = ['api-paste.ini', 'armada.conf.sample']
         with mock.patch.object(armada.conf,
                                '_get_config_files') as mock_get_config_files:

armada/tests/unit/api/test_api_initialization.py

@@ -20,7 +20,6 @@ from armada.tests.unit.api import base as test_base
 
 
 class TestApi(test_base.BaseControllerTest):
-
     def test_init_application(self):
         server = importlib.import_module('armada.api.server')
         api = server.create()

armada/tests/unit/api/test_armada_controller.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 import json
-import mock
 
+import mock
 from oslo_config import cfg
 
 from armada import api
@@ -26,15 +26,14 @@ from armada.tests.unit.api import base
 CONF = cfg.CONF
 
 
-@mock.patch.object(armada_api.Apply, 'handle',
-                   armada_api.Apply.handle.__wrapped__)
+@mock.patch.object(
+    armada_api.Apply, 'handle', armada_api.Apply.handle.__wrapped__)
 class ArmadaControllerTest(base.BaseControllerTest):
-
     @mock.patch.object(api, 'Tiller')
     @mock.patch.object(armada_api, 'Armada')
     @mock.patch.object(armada_api, 'ReferenceResolver')
-    def test_armada_apply_resource(self, mock_resolver, mock_armada,
-                                   mock_tiller):
+    def test_armada_apply_resource(
+            self, mock_resolver, mock_armada, mock_tiller):
         """Tests the POST /api/v1.0/apply endpoint."""
         rules = {'armada:create_endpoints': '@'}
         self.policy.set_rules(rules)
@@ -84,9 +83,10 @@ class ArmadaControllerTest(base.BaseControllerTest):
         self.assertEqual('application/json', result.headers['content-type'])
 
         mock_resolver.resolve_reference.assert_called_with([payload_url])
-        mock_armada.assert_called_with([{
-            'foo': 'bar'
-        }], **expected_armada_options)
+        mock_armada.assert_called_with(
+            [{
+                'foo': 'bar'
+            }], **expected_armada_options)
         mock_armada.return_value.sync.assert_called()
 
         mock_tiller.assert_called_with(dry_run=False)
@@ -119,7 +119,6 @@ class ArmadaControllerTest(base.BaseControllerTest):
 
 
 class ArmadaControllerNegativeTest(base.BaseControllerTest):
-
     @test_utils.attr(type=['negative'])
     def test_armada_apply_raises_415_given_unsupported_media_type(self):
         """Tests the POST /api/v1.0/apply endpoint returns 415 given
@@ -133,7 +132,6 @@ class ArmadaControllerNegativeTest(base.BaseControllerTest):
 
 
 class ArmadaControllerNegativeRbacTest(base.BaseControllerTest):
-
     @test_utils.attr(type=['negative'])
     def test_armada_apply_resource_insufficient_permissions(self):
         """Tests the POST /api/v1.0/apply endpoint returns 403 following failed

armada/tests/unit/api/test_health_controller.py

@@ -18,7 +18,6 @@ from armada.tests.unit.api import base
 
 
 class HealthControllerTest(base.BaseControllerTest):
-
     def test_get_health_status(self):
         """
         Validate that /api/v1.0/health returns 204.

armada/tests/unit/api/test_rollback_controller.py

@@ -23,10 +23,9 @@ from armada.tests.unit.api import base
 from armada.api.controller import rollback
 
 
-@mock.patch.object(rollback.Rollback, 'handle',
-                   rollback.Rollback.handle.__wrapped__)
+@mock.patch.object(
+    rollback.Rollback, 'handle', rollback.Rollback.handle.__wrapped__)
 class RollbackReleaseControllerTest(base.BaseControllerTest):
-
     @mock.patch.object(api, 'Tiller')
     def test_rollback_controller_pass(self, mock_tiller):
         rules = {'armada:rollback_release': '@'}
@@ -62,14 +61,14 @@ class RollbackReleaseControllerTest(base.BaseControllerTest):
             release, 2, wait=True, timeout=123, force=True, recreate_pods=True)
 
         self.assertEqual(200, resp.status_code)
-        self.assertEqual('Rollback of test-release complete.',
-                         json.loads(resp.text)['message'])
+        self.assertEqual(
+            'Rollback of test-release complete.',
+            json.loads(resp.text)['message'])
         m_tiller.__exit__.assert_called()
 
 
 @test_utils.attr(type=['negative'])
 class RollbackReleaseControllerNegativeTest(base.BaseControllerTest):
-
     @mock.patch.object(api, 'Tiller')
     def test_rollback_controller_tiller_exc_return_500(self, mock_tiller):
         rules = {'armada:rollback_release': '@'}
@@ -83,7 +82,6 @@ class RollbackReleaseControllerNegativeTest(base.BaseControllerTest):
 
 @test_utils.attr(type=['negative'])
 class RollbackReleaseControllerNegativeRbacTest(base.BaseControllerTest):
-
     def test_rollback_release_insufficient_permissions(self):
         """Tests the GET /api/v1.0/rollback/{release} endpoint returns 403
         following failed authorization.

armada/tests/unit/api/test_test_controller.py

@@ -14,9 +14,9 @@
 
 import json
 import os
-import yaml
 
 import mock
+import yaml
 
 from armada import api
 from armada.api.controller import test
@@ -26,10 +26,10 @@ from armada.tests import test_utils
 from armada.tests.unit.api import base
 
 
-@mock.patch.object(test.TestReleasesManifestController, 'handle',
-                   test.TestReleasesManifestController.handle.__wrapped__)
+@mock.patch.object(
+    test.TestReleasesManifestController, 'handle',
+    test.TestReleasesManifestController.handle.__wrapped__)
 class TestReleasesManifestControllerTest(base.BaseControllerTest):
-
     @mock.patch.object(test, 'Manifest')
     @mock.patch.object(api, 'Tiller')
     def test_test_controller_with_manifest(self, mock_tiller, mock_manifest):
@@ -38,8 +38,8 @@ class TestReleasesManifestControllerTest(base.BaseControllerTest):
 
         # TODO: Don't use example charts in tests.
         # TODO: Test cleanup arg is taken from url, then manifest.
-        manifest_path = os.path.join(os.getcwd(), 'examples',
-                                     'keystone-manifest.yaml')
+        manifest_path = os.path.join(
+            os.getcwd(), 'examples', 'keystone-manifest.yaml')
         with open(manifest_path, 'r') as f:
             payload = f.read()
         documents = list(yaml.safe_load_all(payload))
@@ -59,14 +59,14 @@ class TestReleasesManifestControllerTest(base.BaseControllerTest):
         m_tiller.__exit__.assert_called()
 
 
-@mock.patch.object(test.TestReleasesReleaseNameController, 'handle',
-                   test.TestReleasesReleaseNameController.handle.__wrapped__)
+@mock.patch.object(
+    test.TestReleasesReleaseNameController, 'handle',
+    test.TestReleasesReleaseNameController.handle.__wrapped__)
 class TestReleasesReleaseNameControllerTest(base.BaseControllerTest):
-
     @mock.patch.object(test.Test, 'test_release_for_success')
     @mock.patch.object(api, 'Tiller')
-    def test_test_controller_test_pass(self, mock_tiller,
-                                       mock_test_release_for_success):
+    def test_test_controller_test_pass(
+            self, mock_tiller, mock_test_release_for_success):
         rules = {'armada:test_release': '@'}
         self.policy.set_rules(rules)
 
@@ -79,14 +79,15 @@ class TestReleasesReleaseNameControllerTest(base.BaseControllerTest):
         resp = self.app.simulate_get('/api/v1.0/test/{}'.format(release))
         mock_test_release_for_success.assert_called_once()
         self.assertEqual(200, resp.status_code)
-        self.assertEqual('MESSAGE: Test Pass',
-                         json.loads(resp.text)['message'])
+        self.assertEqual(
+            'MESSAGE: Test Pass',
+            json.loads(resp.text)['message'])
         m_tiller.__exit__.assert_called()
 
     @mock.patch.object(test.Test, 'test_release_for_success')
     @mock.patch.object(api, 'Tiller')
-    def test_test_controller_test_fail(self, mock_tiller,
-                                       mock_test_release_for_success):
+    def test_test_controller_test_fail(
+            self, mock_tiller, mock_test_release_for_success):
         rules = {'armada:test_release': '@'}
         self.policy.set_rules(rules)
 
@@ -97,14 +98,15 @@ class TestReleasesReleaseNameControllerTest(base.BaseControllerTest):
         release = 'fake-release'
         resp = self.app.simulate_get('/api/v1.0/test/{}'.format(release))
         self.assertEqual(200, resp.status_code)
-        self.assertEqual('MESSAGE: Test Fail',
-                         json.loads(resp.text)['message'])
+        self.assertEqual(
+            'MESSAGE: Test Fail',
+            json.loads(resp.text)['message'])
         m_tiller.__exit__.assert_called()
 
     @mock.patch.object(test.Test, 'test_release_for_success')
     @mock.patch.object(api, 'Tiller')
-    def test_test_controller_cleanup(self, mock_tiller,
-                                     mock_test_release_for_success):
+    def test_test_controller_cleanup(
+            self, mock_tiller, mock_test_release_for_success):
         rules = {'armada:test_release': '@'}
         self.policy.set_rules(rules)
 
@@ -117,16 +119,17 @@ class TestReleasesReleaseNameControllerTest(base.BaseControllerTest):
             '/api/v1.0/test/{}'.format(release), query_string='cleanup=true')
         mock_test_release_for_success.assert_called_once()
         self.assertEqual(200, resp.status_code)
-        self.assertEqual('MESSAGE: Test Pass',
-                         json.loads(resp.text)['message'])
+        self.assertEqual(
+            'MESSAGE: Test Pass',
+            json.loads(resp.text)['message'])
         m_tiller.__exit__.assert_called()
 
 
 @test_utils.attr(type=['negative'])
-@mock.patch.object(test.TestReleasesManifestController, 'handle',
-                   test.TestReleasesManifestController.handle.__wrapped__)
+@mock.patch.object(
+    test.TestReleasesManifestController, 'handle',
+    test.TestReleasesManifestController.handle.__wrapped__)
 class TestReleasesManifestControllerNegativeTest(base.BaseControllerTest):
-
     @mock.patch.object(test, 'Manifest')
     @mock.patch.object(api, 'Tiller')
     @mock.patch.object(test.Test, 'test_release_for_success')
@@ -148,8 +151,8 @@ class TestReleasesManifestControllerNegativeTest(base.BaseControllerTest):
         rules = {'armada:test_manifest': '@'}
         self.policy.set_rules(rules)
 
-        manifest_path = os.path.join(os.getcwd(), 'examples',
-                                     'keystone-manifest.yaml')
+        manifest_path = os.path.join(
+            os.getcwd(), 'examples', 'keystone-manifest.yaml')
         with open(manifest_path, 'r') as f:
             payload = f.read()
 
@@ -166,22 +169,22 @@ class TestReleasesManifestControllerNegativeTest(base.BaseControllerTest):
         resp_body = json.loads(resp.text)
         self.assertEqual(400, resp_body['code'])
         self.assertEqual(1, resp_body['details']['errorCount'])
-        self.assertIn({
-            'message':
-            ('An error occurred while building chart group: '
-             'Could not build ChartGroup named "keystone-infra-services".'),
-            'error':
-            True,
-            'kind':
-            'ValidationMessage',
-            'level':
-            'Error',
-            'name':
-            'ARM001',
-            'documents': []
-        }, resp_body['details']['messageList'])
-        self.assertEqual(('Failed to validate documents or generate Armada '
-                          'Manifest from documents.'), resp_body['message'])
+        self.assertIn(
+            {
+                'message': (
+                    'An error occurred while building chart group: '
+                    'Could not build ChartGroup named '
+                    '"keystone-infra-services".'),
+                'error': True,
+                'kind': 'ValidationMessage',
+                'level': 'Error',
+                'name': 'ARM001',
+                'documents': []
+            }, resp_body['details']['messageList'])
+        self.assertEqual(
+            (
+                'Failed to validate documents or generate Armada '
+                'Manifest from documents.'), resp_body['message'])
         m_tiller.__exit__.assert_called()
 
     @mock.patch('armada.utils.validate.Manifest')
@@ -194,8 +197,8 @@ class TestReleasesManifestControllerNegativeTest(base.BaseControllerTest):
         mock_manifest.return_value.get_manifest.side_effect = (
             manifest_exceptions.ManifestException(details='foo'))
 
-        manifest_path = os.path.join(os.getcwd(), 'examples',
-                                     'keystone-manifest.yaml')
+        manifest_path = os.path.join(
+            os.getcwd(), 'examples', 'keystone-manifest.yaml')
         with open(manifest_path, 'r') as f:
             payload = f.read()
 
@@ -208,27 +211,28 @@ class TestReleasesManifestControllerNegativeTest(base.BaseControllerTest):
         resp_body = json.loads(resp.text)
         self.assertEqual(400, resp_body['code'])
         self.assertEqual(1, resp_body['details']['errorCount'])
-        self.assertEqual([{
-            'message':
-            ('An error occurred while generating the manifest: foo.'),
-            'error':
-            True,
-            'kind':
-            'ValidationMessage',
-            'level':
-            'Error',
-            'name':
-            'ARM001',
-            'documents': []
-        }], resp_body['details']['messageList'])
-        self.assertEqual(('Failed to validate documents or generate Armada '
-                          'Manifest from documents.'), resp_body['message'])
+        self.assertEqual(
+            [
+                {
+                    'message': (
+                        'An error occurred while generating the manifest: foo.'
+                    ),
+                    'error': True,
+                    'kind': 'ValidationMessage',
+                    'level': 'Error',
+                    'name': 'ARM001',
+                    'documents': []
+                }
+            ], resp_body['details']['messageList'])
+        self.assertEqual(
+            (
+                'Failed to validate documents or generate Armada '
+                'Manifest from documents.'), resp_body['message'])
         m_tiller.__exit__.assert_called()
 
 
 @test_utils.attr(type=['negative'])
 class TestReleasesReleaseNameControllerNegativeTest(base.BaseControllerTest):
-
     @mock.patch.object(api, 'Tiller')
     @mock.patch.object(test.Test, 'test_release_for_success')
     def test_test_controller_tiller_exc_returns_500(
@@ -243,9 +247,8 @@ class TestReleasesReleaseNameControllerNegativeTest(base.BaseControllerTest):
         self.assertEqual(500, resp.status_code)
 
 
-class TestReleasesReleaseNameControllerNegativeRbacTest(
-        base.BaseControllerTest):
-
+class TestReleasesReleaseNameControllerNegativeRbacTest(base.BaseControllerTest
+                                                        ):
     @test_utils.attr(type=['negative'])
     def test_test_release_insufficient_permissions(self):
         """Tests the GET /api/v1.0/test/{release} endpoint returns 403
@@ -258,7 +261,6 @@ class TestReleasesReleaseNameControllerNegativeRbacTest(
 
 
 class TestReleasesManifestControllerNegativeRbacTest(base.BaseControllerTest):
-
     @test_utils.attr(type=['negative'])
     def test_test_manifest_insufficient_permissions(self):
         """Tests the POST /api/v1.0/tests endpoint returns 403 following failed

armada/tests/unit/api/test_tiller_controller.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import mock
-
 from oslo_config import cfg
 
 from armada import api
@@ -25,7 +24,6 @@ CONF = cfg.CONF
 
 
 class TillerControllerTest(base.BaseControllerTest):
-
     @mock.patch.object(api, 'Tiller')
     def test_get_tiller_status(self, mock_tiller):
         """Tests GET /api/v1.0/status endpoint."""
@@ -140,7 +138,6 @@ class TillerControllerTest(base.BaseControllerTest):
 
 
 class TillerControllerNegativeRbacTest(base.BaseControllerTest):
-
     @test_utils.attr(type=['negative'])
     def test_list_tiller_releases_insufficient_permissions(self):
         """Tests the GET /api/v1.0/releases endpoint returns 403 following

armada/tests/unit/api/test_validation_controller.py

@@ -18,7 +18,6 @@ from armada.tests.unit.api import base
 
 
 class ValidationControllerNegativeRbacTest(base.BaseControllerTest):
-
     @test_utils.attr(type=['negative'])
     def test_validate_manifest_insufficient_permissions(self):
         """Tests the POST /api/v1.0/validate endpoint returns 403 following

armada/tests/unit/api/test_versions_controller.py

@@ -16,7 +16,6 @@ from armada.tests.unit.api import base
 
 
 class VersionsControllerTest(base.BaseControllerTest):
-
     def test_list_versions(self):
         """
         Validate that /api/v1.0/health returns 204.

armada/tests/unit/base.py

@@ -42,7 +42,6 @@ def is_connected():
 
 
 class ArmadaTestCase(testtools.TestCase):
-
     def setUp(self):
         super(ArmadaTestCase, self).setUp()
         self.useFixture(fixtures.FakeLogger('armada'))

armada/tests/unit/common/test_policy.py

@@ -10,10 +10,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import testtools
-
 import mock
 from oslo_policy import policy as common_policy
+import testtools
 
 from armada.common import policy
 from armada import conf as cfg
@@ -24,7 +23,6 @@ CONF = cfg.CONF
 
 
 class PolicyTestCase(testtools.TestCase):
-
     def setUp(self):
         super(PolicyTestCase, self).setUp()
         self.rules = {
@@ -48,8 +46,9 @@ class PolicyTestCase(testtools.TestCase):
         action = "example:nope"
         mock_ctx.to_policy_view.return_value = self.credentials
 
-        self.assertRaises(exc.ActionForbidden, policy._enforce_policy, action,
-                          self.target, mock_ctx)
+        self.assertRaises(
+            exc.ActionForbidden, policy._enforce_policy, action, self.target,
+            mock_ctx)
         mock_log.exception.assert_called_once_with(
             'Policy not registered for %(action)s', {'action': 'example:nope'})
 
@@ -67,5 +66,6 @@ class PolicyTestCase(testtools.TestCase):
         action = "armada:create_endpoints"
         mock_ctx.to_policy_view.return_value = self.credentials
 
-        self.assertRaises(exc.ActionForbidden, policy._enforce_policy, action,
-                          self.target, mock_ctx)
+        self.assertRaises(
+            exc.ActionForbidden, policy._enforce_policy, action, self.target,
+            mock_ctx)

armada/tests/unit/common/test_session.py

@@ -12,15 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import testtools
-
 import responses
+import testtools
 
 from armada.common.session import ArmadaSession
 
 
 class SessionTestCase(testtools.TestCase):
-
     def test_create_session(self):
         """Tests setting up an Armada session"""
         sess = ArmadaSession("testarmada")

armada/tests/unit/fixtures.py

@@ -19,13 +19,13 @@
 from __future__ import absolute_import
 
 import os
-import yaml
 
 import fixtures
 import mock
 from oslo_config import cfg
 from oslo_policy import opts as policy_opts
 from oslo_policy import policy as oslo_policy
+import yaml
 
 from armada.common import policies
 import armada.common.policy

armada/tests/unit/handlers/test_armada.py

@@ -145,15 +145,15 @@ data:
       enabled: true
 """
 
-CHART_SOURCES = [('git://opendev.org/dummy/armada.git', 'chart_1'),
-                 ('/tmp/dummy/armada', 'chart_2'),
-                 ('/tmp/dummy/armada', 'chart_3'),
-                 ('/tmp/dummy/armada', 'chart_4')]
+CHART_SOURCES = [
+    ('git://opendev.org/dummy/armada.git', 'chart_1'),
+    ('/tmp/dummy/armada', 'chart_2'), ('/tmp/dummy/armada', 'chart_3'),
+    ('/tmp/dummy/armada', 'chart_4')
+]
 
 
 # TODO(seaneagan): Add unit tests with dependencies, including transitive.
 class ArmadaHandlerTestCase(base.ArmadaTestCase):
-
     def _test_pre_flight_ops(self, armada_obj):
         armada_obj.pre_flight_ops()
 
@@ -343,8 +343,8 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
         armada_obj.post_flight_ops()
 
         for group in armada_obj.manifest['data']['chart_groups']:
-            for counter, chart in enumerate(
-                    group.get(const.KEYWORD_DATA).get(const.KEYWORD_CHARTS)):
+            for counter, chart in enumerate(group.get(const.KEYWORD_DATA).get(
+                    const.KEYWORD_CHARTS)):
                 if chart.get(
                         const.KEYWORD_DATA).get('source').get('type') == 'git':
                     mock_source.source_cleanup.assert_called_with(
@@ -355,20 +355,22 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
     # run sync tests for unsequenced as well by moving them to separate test
     # class with two separate subclasses which set chart group `sequenced`
     # field, one to true, one to false.
-    def _test_sync(self,
-                   known_releases,
-                   test_success=True,
-                   test_failure_to_run=False,
-                   expected_last_test_result=None,
-                   diff={'some_key': {'some diff'}}):
+    def _test_sync(
+            self,
+            known_releases,
+            test_success=True,
+            test_failure_to_run=False,
+            expected_last_test_result=None,
+            diff={'some_key': {'some diff'}}):
         """Test install functionality from the sync() method."""
 
         @mock.patch.object(armada.Armada, 'post_flight_ops')
         @mock.patch.object(armada.Armada, 'pre_flight_ops')
         @mock.patch('armada.handlers.chart_deploy.ChartBuilder')
         @mock.patch('armada.handlers.chart_deploy.Test')
-        def _do_test(mock_test, mock_chartbuilder, mock_pre_flight,
-                     mock_post_flight):
+        def _do_test(
+                mock_test, mock_chartbuilder, mock_pre_flight,
+                mock_post_flight):
             # Instantiate Armada object.
             yaml_documents = list(yaml.safe_load_all(TEST_YAML))
 
@@ -417,8 +419,8 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
                 release_name = release_prefixer(prefix, release)
                 # Simplified check because the actual code uses logical-or's
                 # multiple conditions, so this is enough.
-                native_wait_enabled = (chart['wait'].get('native', {}).get(
-                    'enabled', True))
+                native_wait_enabled = (
+                    chart['wait'].get('native', {}).get('enabled', True))
 
                 if release_name not in [x.name for x in known_releases]:
                     expected_install_release_calls.append(
@@ -503,8 +505,8 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
             any_order = not chart_group['sequenced']
             # Verify that at least 1 release is either installed or updated.
             self.assertTrue(
-                len(expected_install_release_calls) >= 1 or
-                len(expected_update_release_calls) >= 1)
+                len(expected_install_release_calls) >= 1
+                or len(expected_update_release_calls) >= 1)
             # Verify that the expected number of non-deployed releases are
             # installed with expected arguments.
             self.assertEqual(
@@ -549,8 +551,8 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
         chart = self._get_chart_by_name(name)
 
         def get_test_result(success):
-            status = (TESTRUN_STATUS_SUCCESS
-                      if success else TESTRUN_STATUS_FAILURE)
+            status = (
+                TESTRUN_STATUS_SUCCESS if success else TESTRUN_STATUS_FAILURE)
             return mock.Mock(status=status)
 
         last_test_suite_run = None
@@ -658,14 +660,12 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
         self.assertRaises(ChartDeployException, _test_method)
 
     def test_armada_sync_test_failure(self):
-
         def _test_method():
             self._test_sync([], test_success=False)
 
         self.assertRaises(ChartDeployException, _test_method)
 
     def test_armada_sync_test_failure_to_run(self):
-
         def _test_method():
             self._test_sync([], test_failure_to_run=True)
 
@@ -673,15 +673,16 @@ class ArmadaHandlerTestCase(base.ArmadaTestCase):
 
 
 class ArmadaNegativeHandlerTestCase(base.ArmadaTestCase):
-
     @mock.patch.object(armada, 'source')
     def test_armada_get_manifest_exception(self, mock_source):
         """Test armada handling with invalid manifest."""
         yaml_documents = list(yaml.safe_load_all(TEST_YAML))
-        error_re = ('.*Documents must include at least one of each of .* and '
-                    'only one .*')
-        self.assertRaisesRegexp(ManifestException, error_re, armada.Armada,
-                                yaml_documents[:1], mock.MagicMock())
+        error_re = (
+            '.*Documents must include at least one of each of .* and '
+            'only one .*')
+        self.assertRaisesRegexp(
+            ManifestException, error_re, armada.Armada, yaml_documents[:1],
+            mock.MagicMock())
 
     @mock.patch.object(armada, 'source')
     def test_armada_override_exception(self, mock_source):

armada/tests/unit/handlers/test_chartbuilder.py

@@ -15,13 +15,13 @@
 import inspect
 import os
 import shutil
-import yaml
 
 import fixtures
 from hapi.chart.chart_pb2 import Chart
 from hapi.chart.metadata_pb2 import Metadata
 import mock
 import testtools
+import yaml
 
 from armada import const
 from armada.handlers.chartbuilder import ChartBuilder
@@ -137,14 +137,13 @@ class BaseChartBuilderTestCase(testtools.TestCase):
 
 
 class ChartBuilderTestCase(BaseChartBuilderTestCase):
-
     def test_source_clone(self):
         # Create a temporary directory with Chart.yaml that contains data
         # from ``self.chart_yaml``.
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
 
         chartbuilder = ChartBuilder(self._get_test_chart(chart_dir))
 
@@ -158,8 +157,9 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
 
         chartbuilder = ChartBuilder(self._get_test_chart(chart_dir))
 
-        self.assertRaises(chartbuilder_exceptions.MetadataLoadException,
-                          chartbuilder.get_metadata)
+        self.assertRaises(
+            chartbuilder_exceptions.MetadataLoadException,
+            chartbuilder.get_metadata)
 
     def test_get_files(self):
         """Validates that ``get_files()`` ignores 'Chart.yaml', 'values.yaml'
@@ -206,8 +206,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         # that that logic has already been performed.
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
         ch = yaml.safe_load(self.chart_stream)
         ch['data']['source_dir'] = (chart_dir.path, '')
 
@@ -215,7 +215,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chartbuilder = ChartBuilder(test_chart)
         helm_chart = chartbuilder.get_helm_chart()
 
-        expected = inspect.cleandoc("""
+        expected = inspect.cleandoc(
+            """
             metadata {
               name: "hello-world-chart"
               version: "0.1.0"
@@ -234,10 +235,10 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
 
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
-        self._write_temporary_file_contents(chart_dir.path, 'values.yaml',
-                                            self.chart_value)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'values.yaml', self.chart_value)
 
         ch = yaml.safe_load(self.chart_stream)
         ch['data']['source_dir'] = (chart_dir.path, '')
@@ -257,15 +258,15 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
         # Chart.yaml is mandatory for `ChartBuilder.get_metadata`.
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
         self._write_temporary_file_contents(chart_dir.path, 'foo', "foobar")
         self._write_temporary_file_contents(chart_dir.path, 'bar', "bazqux")
 
         # Also create a nested directory and verify that files from it are also
         # added.
-        nested_dir = self._make_temporary_subdirectory(chart_dir.path,
-                                                       'nested')
+        nested_dir = self._make_temporary_subdirectory(
+            chart_dir.path, 'nested')
         self._write_temporary_file_contents(nested_dir, 'nested0', "random")
 
         ch = yaml.safe_load(self.chart_stream)
@@ -275,10 +276,11 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chartbuilder = ChartBuilder(test_chart)
         helm_chart = chartbuilder.get_helm_chart()
 
-        expected_files = ('[type_url: "%s"\nvalue: "bazqux"\n, '
-                          'type_url: "%s"\nvalue: "foobar"\n, '
-                          'type_url: "%s"\nvalue: "random"\n]' %
-                          ('./bar', './foo', 'nested/nested0'))
+        expected_files = (
+            '[type_url: "%s"\nvalue: "bazqux"\n, '
+            'type_url: "%s"\nvalue: "foobar"\n, '
+            'type_url: "%s"\nvalue: "random"\n]' %
+            ('./bar', './foo', 'nested/nested0'))
 
         self.assertIsInstance(helm_chart, Chart)
         self.assertTrue(hasattr(helm_chart, 'metadata'))
@@ -300,8 +302,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         charts_nested_subdir = self._make_temporary_subdirectory(
             charts_subdir, 'extra')
 
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
         self._write_temporary_file_contents(chart_dir.path, 'foo', "foobar")
         self._write_temporary_file_contents(chart_dir.path, 'bar', "bazqux")
 
@@ -311,16 +313,16 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
             self._write_temporary_file_contents(chart_dir.path, file, "")
         file_to_ignore = 'file_to_ignore'
         # Files to ignore within templates/ subdirectory.
-        self._write_temporary_file_contents(templates_subdir, file_to_ignore,
-                                            "")
+        self._write_temporary_file_contents(
+            templates_subdir, file_to_ignore, "")
         # Files to ignore within charts/ subdirectory.
         self._write_temporary_file_contents(charts_subdir, file_to_ignore, "")
         # Files to ignore within templates/bin subdirectory.
-        self._write_temporary_file_contents(templates_nested_subdir,
-                                            file_to_ignore, "")
+        self._write_temporary_file_contents(
+            templates_nested_subdir, file_to_ignore, "")
         # Files to ignore within charts/extra subdirectory.
-        self._write_temporary_file_contents(charts_nested_subdir,
-                                            file_to_ignore, "")
+        self._write_temporary_file_contents(
+            charts_nested_subdir, file_to_ignore, "")
         # Files to **include** within charts/ subdirectory.
         self._write_temporary_file_contents(charts_subdir, '.prov', "xyzzy")
 
@@ -331,10 +333,11 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chartbuilder = ChartBuilder(test_chart)
         helm_chart = chartbuilder.get_helm_chart()
 
-        expected_files = ('[type_url: "%s"\nvalue: "bazqux"\n, '
-                          'type_url: "%s"\nvalue: "foobar"\n, '
-                          'type_url: "%s"\nvalue: "xyzzy"\n]' %
-                          ('./bar', './foo', 'charts/.prov'))
+        expected_files = (
+            '[type_url: "%s"\nvalue: "bazqux"\n, '
+            'type_url: "%s"\nvalue: "foobar"\n, '
+            'type_url: "%s"\nvalue: "xyzzy"\n]' %
+            ('./bar', './foo', 'charts/.prov'))
 
         # Validate that only relevant files are included, that the ignored
         # files are present.
@@ -349,16 +352,16 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         # Main chart directory and files.
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
         ch = yaml.safe_load(self.chart_stream)
         ch['data']['source_dir'] = (chart_dir.path, '')
 
         # Dependency chart directory and files.
         dep_chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, dep_chart_dir.path)
-        self._write_temporary_file_contents(dep_chart_dir.path, 'Chart.yaml',
-                                            self.dependency_chart_yaml)
+        self._write_temporary_file_contents(
+            dep_chart_dir.path, 'Chart.yaml', self.dependency_chart_yaml)
         dep_ch = yaml.safe_load(self.dependency_chart_stream)
         dep_ch['data']['source_dir'] = (dep_chart_dir.path, '')
 
@@ -369,7 +372,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         chartbuilder = ChartBuilder(main_chart)
         helm_chart = chartbuilder.get_helm_chart()
 
-        expected_dependency = inspect.cleandoc("""
+        expected_dependency = inspect.cleandoc(
+            """
             metadata {
               name: "dependency-chart"
               version: "0.1.0"
@@ -379,7 +383,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
             }
         """).strip()
 
-        expected = inspect.cleandoc("""
+        expected = inspect.cleandoc(
+            """
             metadata {
               name: "hello-world-chart"
               version: "0.1.0"
@@ -418,8 +423,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         # Validate base case.
         chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, chart_dir.path)
-        self._write_temporary_file_contents(chart_dir.path, 'Chart.yaml',
-                                            self.chart_yaml)
+        self._write_temporary_file_contents(
+            chart_dir.path, 'Chart.yaml', self.chart_yaml)
         ch = yaml.safe_load(self.chart_stream)
         ch['data']['source_dir'] = (chart_dir.path, '')
 
@@ -432,8 +437,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         # Validate recursive case (with dependencies).
         dep_chart_dir = self.useFixture(fixtures.TempDir())
         self.addCleanup(shutil.rmtree, dep_chart_dir.path)
-        self._write_temporary_file_contents(dep_chart_dir.path, 'Chart.yaml',
-                                            self.dependency_chart_yaml)
+        self._write_temporary_file_contents(
+            dep_chart_dir.path, 'Chart.yaml', self.dependency_chart_yaml)
         dep_ch = yaml.safe_load(self.dependency_chart_stream)
         dep_ch['data']['source_dir'] = (dep_chart_dir.path, '')
 
@@ -441,7 +446,8 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
         test_chart['data']['dependencies'] = [dependency_chart]
         chartbuilder = ChartBuilder(test_chart)
 
-        re = inspect.cleandoc("""
+        re = inspect.cleandoc(
+            """
             hello-world-chart.*A sample Helm chart for Kubernetes.*
             dependency-chart.*Another sample Helm chart for Kubernetes.*
         """).replace('\n', '').strip()
@@ -449,7 +455,6 @@ class ChartBuilderTestCase(BaseChartBuilderTestCase):
 
 
 class ChartBuilderNegativeTestCase(BaseChartBuilderTestCase):
-
     def setUp(self):
         super(ChartBuilderNegativeTestCase, self).setUp()
         # Create an exception for testing since instantiating one manually
@@ -471,13 +476,15 @@ class ChartBuilderNegativeTestCase(BaseChartBuilderTestCase):
         chartbuilder = ChartBuilder(self._get_test_chart(chart_dir))
 
         # Confirm it failed for both encodings.
-        error_re = (r'.*A str exception occurred while trying to read file:'
-                    r'.*Details:\n.*\(encoding=utf-8\).*\n\(encoding=latin1\)')
+        error_re = (
+            r'.*A str exception occurred while trying to read file:'
+            r'.*Details:\n.*\(encoding=utf-8\).*\n\(encoding=latin1\)')
         with mock.patch("builtins.open", mock.mock_open(read_data="")) \
                 as mock_file:
             mock_file.return_value.read.side_effect = self.exc_to_raise
-            self.assertRaisesRegexp(chartbuilder_exceptions.FilesLoadException,
-                                    error_re, chartbuilder.get_files)
+            self.assertRaisesRegexp(
+                chartbuilder_exceptions.FilesLoadException, error_re,
+                chartbuilder.get_files)
 
     def test_get_files_fails_once_to_read_binary_file_passes(self):
         chart_dir = self.useFixture(fixtures.TempDir())

armada/tests/unit/handlers/test_lock.py

@@ -11,20 +11,20 @@
 # 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.
+
 import copy
 from datetime import datetime
 
+from kubernetes.client.rest import ApiException
 import mock
 import testtools
 
-from kubernetes.client.rest import ApiException
 from armada.handlers import lock
 
 
 @mock.patch('armada.handlers.lock.K8s')
 @mock.patch.object(lock.time, 'sleep', lambda x: True)
 class LockTestCase(testtools.TestCase):
-
     def __init__(self, *args, **kwargs):
         super(LockTestCase, self).__init__(*args, **kwargs)
         self.resp = None

armada/tests/unit/handlers/test_manifest.py

@@ -14,9 +14,9 @@
 
 import copy
 import os
-import yaml
 
-import testtools
+import testtools
+import yaml
 
 from armada import exceptions
 from armada.handlers import manifest
@@ -25,11 +25,10 @@ from armada.utils import validate
 
 
 class ManifestTestCase(testtools.TestCase):
-
     def setUp(self):
         super(ManifestTestCase, self).setUp()
-        examples_dir = os.path.join(os.getcwd(), 'armada', 'tests', 'unit',
-                                    'resources')
+        examples_dir = os.path.join(
+            os.getcwd(), 'armada', 'tests', 'unit', 'resources')
         with open(os.path.join(examples_dir, 'keystone-manifest.yaml')) as f:
             self.documents = list(yaml.safe_load_all(f.read()))
 
@@ -43,10 +42,10 @@ class ManifestTestCase(testtools.TestCase):
         self.assertEqual(5, len(armada_manifest.charts))
         self.assertEqual(3, len(armada_manifest.groups))
 
-        self.assertEqual([self.documents[x] for x in range(5)],
-                         armada_manifest.charts)
-        self.assertEqual([self.documents[x] for x in range(5, 8)],
-                         armada_manifest.groups)
+        self.assertEqual(
+            [self.documents[x] for x in range(5)], armada_manifest.charts)
+        self.assertEqual(
+            [self.documents[x] for x in range(5, 8)], armada_manifest.groups)
         self.assertEqual(self.documents[-1], armada_manifest.manifest)
 
     def test_get_documents_with_target_manifest(self):
@@ -62,13 +61,13 @@ class ManifestTestCase(testtools.TestCase):
         self.assertEqual(5, len(armada_manifest.charts))
         self.assertEqual(3, len(armada_manifest.groups))
 
-        self.assertEqual([self.documents[x] for x in range(5)],
-                         armada_manifest.charts)
-        self.assertEqual([self.documents[x] for x in range(5, 8)],
-                         armada_manifest.groups)
+        self.assertEqual(
+            [self.documents[x] for x in range(5)], armada_manifest.charts)
+        self.assertEqual(
+            [self.documents[x] for x in range(5, 8)], armada_manifest.groups)
         self.assertEqual(self.documents[-1], armada_manifest.manifest)
-        self.assertEqual('armada-manifest',
-                         self.documents[-1]['metadata']['name'])
+        self.assertEqual(
+            'armada-manifest', self.documents[-1]['metadata']['name'])
 
     def test_get_documents_with_multi_manifest_and_target_manifest(self):
         # Validate that specifying `target_manifest` flag returns the correct
@@ -90,29 +89,30 @@ class ManifestTestCase(testtools.TestCase):
         self.assertEqual(5, len(armada_manifest.charts))
         self.assertEqual(3, len(armada_manifest.groups))
 
-        self.assertEqual([self.documents[x] for x in range(5)],
-                         armada_manifest.charts)
-        self.assertEqual([self.documents[x] for x in range(5, 8)],
-                         armada_manifest.groups)
+        self.assertEqual(
+            [self.documents[x] for x in range(5)], armada_manifest.charts)
+        self.assertEqual(
+            [self.documents[x] for x in range(5, 8)], armada_manifest.groups)
         self.assertEqual(armada_manifest.manifest, self.documents[-1])
-        self.assertEqual('armada-manifest',
-                         armada_manifest.manifest['metadata']['name'])
+        self.assertEqual(
+            'armada-manifest', armada_manifest.manifest['metadata']['name'])
 
         # Specify the alternative manifest and verify it works.
         armada_manifest = manifest.Manifest(
             documents, target_manifest='alt-armada-manifest')
         self.assertIsNotNone(armada_manifest.manifest)
         self.assertEqual(other_manifest, armada_manifest.manifest)
-        self.assertEqual('alt-armada-manifest',
-                         armada_manifest.manifest['metadata']['name'])
+        self.assertEqual(
+            'alt-armada-manifest',
+            armada_manifest.manifest['metadata']['name'])
 
     def test_get_manifest(self):
         armada_manifest = manifest.Manifest(
             self.documents, target_manifest='armada-manifest')
         obtained_manifest = armada_manifest.get_manifest()
         self.assertIsInstance(obtained_manifest, dict)
-        self.assertEqual(obtained_manifest['data'],
-                         armada_manifest.manifest['data'])
+        self.assertEqual(
+            obtained_manifest['data'], armada_manifest.manifest['data'])
 
     def test_find_documents(self):
         armada_manifest = manifest.Manifest(self.documents)
@@ -195,15 +195,17 @@ class ManifestTestCase(testtools.TestCase):
         keystone_infra_services_chart_group = armada_manifest. \
             find_chart_group_document('keystone-infra-services')
 
-        self.assertEqual(keystone_infra_services_chart_group,
-                         built_armada_manifest['data']['chart_groups'][0])
+        self.assertEqual(
+            keystone_infra_services_chart_group,
+            built_armada_manifest['data']['chart_groups'][0])
 
         # the first chart group in the Armada manifest
         openstack_keystone_chart_group = armada_manifest. \
             find_chart_group_document('openstack-keystone')
 
-        self.assertEqual(openstack_keystone_chart_group,
-                         built_armada_manifest['data']['chart_groups'][1])
+        self.assertEqual(
+            openstack_keystone_chart_group,
+            built_armada_manifest['data']['chart_groups'][1])
 
     def test_verify_build_chart_group_deps(self):
         armada_manifest = manifest.Manifest(self.documents)
@@ -223,8 +225,9 @@ class ManifestTestCase(testtools.TestCase):
         keystone_dependencies = keystone_chart_with_deps['data'][
             'dependencies']
 
-        self.assertEqual(openstack_keystone_chart_group_deps_dep_added[0],
-                         keystone_dependencies[0])
+        self.assertEqual(
+            openstack_keystone_chart_group_deps_dep_added[0],
+            keystone_dependencies[0])
 
         # building the deps for openstack-keystone chart group
         chart_group = armada_manifest.find_chart_group_document(
@@ -248,10 +251,10 @@ class ManifestTestCase(testtools.TestCase):
         memcached_dependencies = memcached_chart_with_deps['data'][
             'dependencies']
 
-        self.assertEqual(keystone_infra_services_dep_added[0],
-                         mariadb_dependencies[0])
-        self.assertEqual(keystone_infra_services_dep_added[0],
-                         memcached_dependencies[0])
+        self.assertEqual(
+            keystone_infra_services_dep_added[0], mariadb_dependencies[0])
+        self.assertEqual(
+            keystone_infra_services_dep_added[0], memcached_dependencies[0])
 
     def test_verify_build_chart_deps(self):
         armada_manifest = manifest.Manifest(self.documents)
@@ -265,8 +268,8 @@ class ManifestTestCase(testtools.TestCase):
 
         # since not dependent on other charts, the original and modified
         # dependencies are the same
-        self.assertEqual(helm_toolkit_original_dependency,
-                         helm_toolkit_chart_with_deps)
+        self.assertEqual(
+            helm_toolkit_original_dependency, helm_toolkit_chart_with_deps)
 
         # helm-toolkit dependency, the basis for comparison of d
         # ependencies in other charts
@@ -287,8 +290,8 @@ class ManifestTestCase(testtools.TestCase):
         self.assertIsInstance(keystone_dependencies, list)
         self.assertEqual(1, len(keystone_dependencies))
 
-        self.assertEqual(expected_helm_toolkit_dependency,
-                         keystone_dependencies[0])
+        self.assertEqual(
+            expected_helm_toolkit_dependency, keystone_dependencies[0])
 
         # mariadb chart dependencies
         mariadb_chart = armada_manifest.find_chart_document('mariadb')
@@ -304,8 +307,8 @@ class ManifestTestCase(testtools.TestCase):
         self.assertIsInstance(mariadb_dependencies, list)
         self.assertEqual(1, len(mariadb_dependencies))
 
-        self.assertEqual(expected_helm_toolkit_dependency,
-                         mariadb_dependencies[0])
+        self.assertEqual(
+            expected_helm_toolkit_dependency, mariadb_dependencies[0])
 
         # memcached chart dependencies
         memcached_chart = armada_manifest.find_chart_document('memcached')
@@ -313,8 +316,8 @@ class ManifestTestCase(testtools.TestCase):
         memcached_chart_with_deps = armada_manifest.build_chart_deps(
             memcached_chart)
 
-        self.assertNotEqual(original_memcached_chart,
-                            memcached_chart_with_deps)
+        self.assertNotEqual(
+            original_memcached_chart, memcached_chart_with_deps)
         self.assertIn('data', memcached_chart_with_deps)
         self.assertIn('dependencies', memcached_chart_with_deps['data'])
 
@@ -323,16 +326,15 @@ class ManifestTestCase(testtools.TestCase):
         self.assertIsInstance(memcached_dependencies, list)
         self.assertEqual(1, len(memcached_dependencies))
 
-        self.assertEqual(expected_helm_toolkit_dependency,
-                         memcached_dependencies[0])
+        self.assertEqual(
+            expected_helm_toolkit_dependency, memcached_dependencies[0])
 
 
 class ManifestNegativeTestCase(testtools.TestCase):
-
     def setUp(self):
         super(ManifestNegativeTestCase, self).setUp()
-        examples_dir = os.path.join(os.getcwd(), 'armada', 'tests', 'unit',
-                                    'resources')
+        examples_dir = os.path.join(
+            os.getcwd(), 'armada', 'tests', 'unit', 'resources')
         with open(os.path.join(examples_dir, 'keystone-manifest.yaml')) as f:
             self.documents = list(yaml.safe_load_all(f.read()))
 
@@ -343,8 +345,9 @@ class ManifestNegativeTestCase(testtools.TestCase):
         documents.append(documents[-1])  # Copy the last manifest.
 
         error_re = r'Multiple manifests are not supported.*'
-        self.assertRaisesRegexp(exceptions.ManifestException, error_re,
-                                manifest.Manifest, documents)
+        self.assertRaisesRegexp(
+            exceptions.ManifestException, error_re, manifest.Manifest,
+            documents)
 
     def test_get_documents_multi_target_manifests_raises_value_error(self):
         # Validates that finding multiple manifests with `target_manifest`
@@ -361,10 +364,12 @@ class ManifestNegativeTestCase(testtools.TestCase):
             target_manifest='armada-manifest')
 
     def _assert_missing_documents_raises(self, documents):
-        error_re = ('.*Documents must include at least one of each of .* and '
-                    'only one .*')
-        self.assertRaisesRegexp(exceptions.ManifestException, error_re,
-                                manifest.Manifest, documents)
+        error_re = (
+            '.*Documents must include at least one of each of .* and '
+            'only one .*')
+        self.assertRaisesRegexp(
+            exceptions.ManifestException, error_re, manifest.Manifest,
+            documents)
 
     def test_get_documents_missing_manifest(self):
         # Validates exceptions.ManifestException is thrown if no manifest is
@@ -384,18 +389,19 @@ class ManifestNegativeTestCase(testtools.TestCase):
 
     def test_find_chart_document_negative(self):
         armada_manifest = manifest.Manifest(self.documents)
-        error_re = r'.*Could not find %s named "%s"' % (schema.TYPE_CHART,
-                                                        'invalid')
-        self.assertRaisesRegexp(exceptions.BuildChartException, error_re,
-                                armada_manifest.find_chart_document, 'invalid')
+        error_re = r'.*Could not find %s named "%s"' % (
+            schema.TYPE_CHART, 'invalid')
+        self.assertRaisesRegexp(
+            exceptions.BuildChartException, error_re,
+            armada_manifest.find_chart_document, 'invalid')
 
     def test_find_group_document_negative(self):
         armada_manifest = manifest.Manifest(self.documents)
-        error_re = r'.*Could not find %s named "%s"' % (schema.TYPE_CHARTGROUP,
-                                                        'invalid')
-        self.assertRaisesRegexp(exceptions.BuildChartGroupException, error_re,
-                                armada_manifest.find_chart_group_document,
-                                'invalid')
+        error_re = r'.*Could not find %s named "%s"' % (
+            schema.TYPE_CHARTGROUP, 'invalid')
+        self.assertRaisesRegexp(
+            exceptions.BuildChartGroupException, error_re,
+            armada_manifest.find_chart_group_document, 'invalid')
 
     def test_build_chart_deps_with_missing_dependency_fails(self):
         """Validate that attempting to build a chart that points to

armada/tests/unit/handlers/test_override.py

@@ -15,9 +15,9 @@
 import copy
 import json
 import os
-import yaml
 
 import testtools
+import yaml
 
 from armada.handlers.override import Override
 from armada.handlers import schema
@@ -25,7 +25,6 @@ from armada.exceptions import override_exceptions
 
 
 class OverrideTestCase(testtools.TestCase):
-
     def setUp(self):
         super(OverrideTestCase, self).setUp()
         self.basepath = os.path.join(os.path.dirname(__file__))
@@ -80,8 +79,9 @@ class OverrideTestCase(testtools.TestCase):
         ][0]
         self.assertEqual('overridden', target_doc['data']['release_prefix'])
 
-        override = ('manifest:simple-armada:chart_groups='
-                    'blog-group3,blog-group4', )
+        override = (
+            'manifest:simple-armada:chart_groups='
+            'blog-group3,blog-group4', )
 
         # Case 2: Checking if list gets updated.
         ovr = Override(original_documents, override, [values_yaml])
@@ -93,8 +93,9 @@ class OverrideTestCase(testtools.TestCase):
         with open(comparison_yaml) as c:
             comparison_documents = list(yaml.safe_load_all(c.read()))
         # verifying that the override is correct
-        self.assertEqual(original_documents[2]['data']['chart_groups'],
-                         comparison_documents[0]['data']['chart_groups'])
+        self.assertEqual(
+            original_documents[2]['data']['chart_groups'],
+            comparison_documents[0]['data']['chart_groups'])
 
     def test_update_manifests_invalid_override_format(self):
         with open(self.base_manifest) as f:
@@ -141,8 +142,9 @@ class OverrideTestCase(testtools.TestCase):
         ovr.update_document(documents_modified[0])
 
         # after the update, both documents are equal
-        self.assertEqual(ovr.documents[0]['data']['chart_name'],
-                         documents_modified[0]['data']['chart_name'])
+        self.assertEqual(
+            ovr.documents[0]['data']['chart_name'],
+            documents_modified[0]['data']['chart_name'])
         self.assertEqual(ovr.documents[0], documents_modified[0])
 
         # Case 2: Checking if dictionaries get updated
@@ -151,8 +153,9 @@ class OverrideTestCase(testtools.TestCase):
         ovr.update_document(documents_modified[0])
 
         # after the update, both documents are equal
-        self.assertEqual(ovr.documents[0]['data']['values'],
-                         documents_modified[0]['data']['values'])
+        self.assertEqual(
+            ovr.documents[0]['data']['values'],
+            documents_modified[0]['data']['values'])
         self.assertEqual(ovr.documents[0], documents_modified[0])
 
         # Case 3: Checking if lists get updated
@@ -161,10 +164,11 @@ class OverrideTestCase(testtools.TestCase):
         ovr.update_document(documents_modified[0])
 
         # after the update, both documents are equal
-        self.assertEqual(['foo', 'bar'],
-                         ovr.documents[0]['data']['dependencies'])
-        self.assertEqual(documents_modified[0]['data']['dependencies'],
-                         ovr.documents[0]['data']['dependencies'])
+        self.assertEqual(
+            ['foo', 'bar'], ovr.documents[0]['data']['dependencies'])
+        self.assertEqual(
+            documents_modified[0]['data']['dependencies'],
+            ovr.documents[0]['data']['dependencies'])
         self.assertEqual(ovr.documents[0], documents_modified[0])
 
     def test_update_chart_document_keys_not_removed_with_override(self):
@@ -198,8 +202,9 @@ class OverrideTestCase(testtools.TestCase):
         ovr.update_document(documents_modified[1])
 
         # after the update, both documents are equal
-        self.assertEqual(ovr.documents[1]['data']['sequenced'],
-                         documents_modified[1]['data']['sequenced'])
+        self.assertEqual(
+            ovr.documents[1]['data']['sequenced'],
+            documents_modified[1]['data']['sequenced'])
         self.assertEqual(ovr.documents[1], documents_modified[1])
 
     def test_update_chart_group_document_keys_not_removed_with_override(self):
@@ -233,8 +238,9 @@ class OverrideTestCase(testtools.TestCase):
         ovr.update_document(documents_modified[2])
 
         # after the update, both documents are equal
-        self.assertEqual(ovr.documents[2]['data']['release_prefix'],
-                         documents_modified[2]['data']['release_prefix'])
+        self.assertEqual(
+            ovr.documents[2]['data']['release_prefix'],
+            documents_modified[2]['data']['release_prefix'])
         self.assertEqual(ovr.documents[2], documents_modified[2])
 
     def test_update_armada_manifest_keys_not_removed_with_override(self):
@@ -278,7 +284,8 @@ class OverrideTestCase(testtools.TestCase):
         with open(self.base_manifest) as f, open(expected) as e:
             documents = list(yaml.safe_load_all(f.read()))
             doc_path = ['manifest', 'simple-armada']
-            override = ('manifest:simple-armada:chart_groups=\
+            override = (
+                'manifest:simple-armada:chart_groups=\
                          blog-group3,blog-group4', )
             ovr = Override(documents, override)
             ovr.update_manifests()
@@ -312,7 +319,6 @@ class OverrideTestCase(testtools.TestCase):
 
 
 class OverrideNegativeTestCase(testtools.TestCase):
-
     def setUp(self):
         super(OverrideNegativeTestCase, self).setUp()
         self.basepath = os.path.join(os.path.dirname(__file__))
@@ -342,8 +348,9 @@ class OverrideNegativeTestCase(testtools.TestCase):
 
         override = ('manifest:simple-armada:name=' 'overridden', )
         ovr = Override(original_documents, override)
-        self.assertRaises(override_exceptions.InvalidOverrideValueException,
-                          ovr.update_manifests)
+        self.assertRaises(
+            override_exceptions.InvalidOverrideValueException,
+            ovr.update_manifests)
 
     def test_load_yaml_file_invalid(self):
         missing_yaml = "{}/templates/non_existing_yaml.yaml". \
@@ -351,15 +358,16 @@ class OverrideNegativeTestCase(testtools.TestCase):
         with open(self.base_manifest) as f:
             documents = list(yaml.safe_load_all(f.read()))
             ovr = Override(documents)
-            self.assertRaises(override_exceptions.InvalidOverrideFileException,
-                              ovr._load_yaml_file, missing_yaml)
+            self.assertRaises(
+                override_exceptions.InvalidOverrideFileException,
+                ovr._load_yaml_file, missing_yaml)
 
     def test_find_document_type_invalid(self):
         with open(self.base_manifest) as f:
             documents = list(yaml.safe_load_all(f.read()))
             ovr = Override(documents)
-            self.assertRaises(ValueError, ovr.find_document_type,
-                              'non_existing_document')
+            self.assertRaises(
+                ValueError, ovr.find_document_type, 'non_existing_document')
 
     def test_convert_array_to_dict_invalid(self):
         data_path = ['a', 'b', 'c']

armada/tests/unit/handlers/test_release_diff.py

@@ -12,20 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from armada.handlers.release_diff import ReleaseDiff
-from armada.tests.unit import base
-
 from google.protobuf.any_pb2 import Any
 from hapi.chart.chart_pb2 import Chart
 from hapi.chart.config_pb2 import Config
 from hapi.chart.metadata_pb2 import Metadata
 from hapi.chart.template_pb2 import Template
 
+from armada.handlers.release_diff import ReleaseDiff
+from armada.tests.unit import base
+
 
 # Tests for diffs which can occur in both top-level or dependency charts,
 # and thus are inherited by both of those test classes.
 class _BaseReleaseDiffTestCase():
-
     def setUp(self):
         super(base.ArmadaTestCase, self).setUp()
         self.old_chart = self.make_chart()
@@ -67,8 +66,9 @@ class _BaseReleaseDiffTestCase():
         new_chart = self.make_chart()
         chart_to_update = self.get_chart_to_update(new_chart)
         update_chart(chart_to_update)
-        diff = ReleaseDiff(self.old_chart, self.old_values, new_chart,
-                           self.old_values).get_diff()
+        diff = ReleaseDiff(
+            self.old_chart, self.old_values, new_chart,
+            self.old_values).get_diff()
         self.assertTrue(diff)
 
     def get_chart_to_update(self, chart):
@@ -78,89 +78,82 @@ class _BaseReleaseDiffTestCase():
         new_chart = self.make_chart()
         chart_to_update = self.get_chart_to_update(new_chart)
         chart_to_update.metadata.description = 'new chart description'
-        diff = ReleaseDiff(self.old_chart, self.old_values, new_chart,
-                           self.old_values).get_diff()
+        diff = ReleaseDiff(
+            self.old_chart, self.old_values, new_chart,
+            self.old_values).get_diff()
         self.assertFalse(diff)
 
     def test_metadata_name_diff(self):
-
         def update_chart(chart):
             chart.metadata.name = 'new_chart_name'
 
         self._test_chart_diff(update_chart)
 
     def test_default_values_diff(self):
-
         def update_chart(chart):
             chart.values.raw = '{param: d2}'
 
         self._test_chart_diff(update_chart)
 
     def test_template_name_diff(self):
-
         def update_chart(chart):
             chart.templates[0].name = 'new_template_name'
 
         self._test_chart_diff(update_chart)
 
     def test_template_data_diff(self):
-
         def update_chart(chart):
             chart.templates[0].data = 'new template content'.encode()
 
         self._test_chart_diff(update_chart)
 
     def test_add_template_diff(self):
-
         def update_chart(chart):
-            chart.templates.extend([
-                Template(
-                    name='new_template_name',
-                    data='new template content'.encode())
-            ])
+            chart.templates.extend(
+                [
+                    Template(
+                        name='new_template_name',
+                        data='new template content'.encode())
+                ])
 
         self._test_chart_diff(update_chart)
 
     def test_remove_template_diff(self):
-
         def update_chart(chart):
             del chart.templates[0]
 
         self._test_chart_diff(update_chart)
 
     def test_file_type_url_diff(self):
-
         def update_chart(chart):
             chart.files[0].type_url = './new_file_name.ext'
 
         self._test_chart_diff(update_chart)
 
     def test_file_value_diff(self):
-
         def update_chart(chart):
             chart.files[0].value = 'new file content'.encode()
 
         self._test_chart_diff(update_chart)
 
     def test_add_file_diff(self):
-
         def update_chart(chart):
-            chart.files.extend([
-                Any(type_url='./new_file_name.ext',
-                    value='new file content'.encode())
-            ])
+            chart.files.extend(
+                [
+                    Any(
+                        type_url='./new_file_name.ext',
+                        value='new file content'.encode())
+                ])
 
         self._test_chart_diff(update_chart)
 
     def test_remove_file_diff(self):
-
         def update_chart(chart):
             del chart.files[0]
 
         self._test_chart_diff(update_chart)
 
     def test_add_dependency_diff(self):
-
         def update_chart(chart):
             dep = self._make_chart()
             dep.metadata.name = 'dep2'
@@ -169,7 +162,6 @@ class _BaseReleaseDiffTestCase():
         self._test_chart_diff(update_chart)
 
     def test_remove_dependency_diff(self):
-
         def update_chart(chart):
             del chart.dependencies[0]
 
@@ -178,26 +170,26 @@ class _BaseReleaseDiffTestCase():
 
 # Test diffs (or absence of) in top-level chart / values.
 class ReleaseDiffTestCase(_BaseReleaseDiffTestCase, base.ArmadaTestCase):
-
     def get_chart_to_update(self, chart):
         return chart
 
     def test_same_input_no_diff(self):
-        diff = ReleaseDiff(self.old_chart, self.old_values, self.make_chart(),
-                           self.make_values()).get_diff()
+        diff = ReleaseDiff(
+            self.old_chart, self.old_values, self.make_chart(),
+            self.make_values()).get_diff()
         self.assertFalse(diff)
 
     def test_override_values_diff(self):
         new_values = {'param': 'o2'}
-        diff = ReleaseDiff(self.old_chart, self.old_values, self.old_chart,
-                           new_values).get_diff()
+        diff = ReleaseDiff(
+            self.old_chart, self.old_values, self.old_chart,
+            new_values).get_diff()
         self.assertTrue(diff)
 
 
 # Test diffs in dependencies.
 class DependencyReleaseDiffTestCase(_BaseReleaseDiffTestCase,
                                     base.ArmadaTestCase):
-
     def get_chart_to_update(self, chart):
         return chart.dependencies[0]
 
@@ -205,6 +197,5 @@ class DependencyReleaseDiffTestCase(_BaseReleaseDiffTestCase,
 # Test diffs in transitive dependencies.
 class TransitiveDependencyReleaseDiffTestCase(_BaseReleaseDiffTestCase,
                                               base.ArmadaTestCase):
-
     def get_chart_to_update(self, chart):
         return chart.dependencies[0].dependencies[0]

armada/tests/unit/handlers/test_test.py

@@ -15,7 +15,6 @@
 import mock
 
 from armada import const
-
 from armada.handlers import test
 from armada.handlers import tiller
 from armada.tests.unit import base
@@ -24,9 +23,7 @@ from armada.utils import helm
 
 
 class TestHandlerTestCase(base.ArmadaTestCase):
-
     def _test_test_release_for_success(self, expected_success, results):
-
         @mock.patch('armada.handlers.tiller.K8s')
         def do_test(_):
             tiller_obj = tiller.Tiller('host', '8080', None)
@@ -47,26 +44,29 @@ class TestHandlerTestCase(base.ArmadaTestCase):
         self._test_test_release_for_success(True, [])
 
     def test_unknown(self):
-        self._test_test_release_for_success(False, [
-            AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
-            AttrDict(**{'status': helm.TESTRUN_STATUS_UNKNOWN})
-        ])
+        self._test_test_release_for_success(
+            False, [
+                AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
+                AttrDict(**{'status': helm.TESTRUN_STATUS_UNKNOWN})
+            ])
 
     def test_success(self):
         self._test_test_release_for_success(
             True, [AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS})])
 
     def test_failure(self):
-        self._test_test_release_for_success(False, [
-            AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
-            AttrDict(**{'status': helm.TESTRUN_STATUS_FAILURE})
-        ])
+        self._test_test_release_for_success(
+            False, [
+                AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
+                AttrDict(**{'status': helm.TESTRUN_STATUS_FAILURE})
+            ])
 
     def test_running(self):
-        self._test_test_release_for_success(False, [
-            AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
-            AttrDict(**{'status': helm.TESTRUN_STATUS_RUNNING})
-        ])
+        self._test_test_release_for_success(
+            False, [
+                AttrDict(**{'status': helm.TESTRUN_STATUS_SUCCESS}),
+                AttrDict(**{'status': helm.TESTRUN_STATUS_RUNNING})
+            ])
 
     def test_cg_disabled(self):
         """Test that tests are disabled when a chart group disables all

armada/tests/unit/handlers/test_tiller.py

@@ -23,15 +23,15 @@ from armada.tests.test_utils import AttrDict
 
 
 class TillerTestCase(base.ArmadaTestCase):
-
     @mock.patch.object(tiller.Tiller, '_get_tiller_ip')
     @mock.patch('armada.handlers.tiller.K8s')
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch('armada.handlers.tiller.Config')
     @mock.patch('armada.handlers.tiller.InstallReleaseRequest')
     @mock.patch('armada.handlers.tiller.ReleaseServiceStub')
-    def test_install_release(self, mock_stub, mock_install_request,
-                             mock_config, mock_grpc, mock_k8s, mock_ip):
+    def test_install_release(
+            self, mock_stub, mock_install_request, mock_config, mock_grpc,
+            mock_k8s, mock_ip):
         # instantiate Tiller object
         mock_grpc.insecure_channel.return_value = mock.Mock()
         mock_ip.return_value = '0.0.0.0'
@@ -63,8 +63,9 @@ class TillerTestCase(base.ArmadaTestCase):
             namespace=namespace,
             wait=wait,
             timeout=timeout)
-        (mock_stub(tiller_obj.channel).InstallRelease.assert_called_with(
-            release_request, timeout + 60, metadata=tiller_obj.metadata))
+        (
+            mock_stub(tiller_obj.channel).InstallRelease.assert_called_with(
+                release_request, timeout + 60, metadata=tiller_obj.metadata))
 
     @mock.patch('armada.handlers.tiller.K8s', autospec=True)
     @mock.patch.object(tiller.Tiller, '_get_tiller_ip', autospec=True)
@@ -85,10 +86,10 @@ class TillerTestCase(base.ArmadaTestCase):
 
         mock_grpc.insecure_channel.assert_called_once_with(
             '%s:%s' % (str(mock.sentinel.ip), str(mock.sentinel.port)),
-            options=[('grpc.max_send_message_length',
-                      tiller.MAX_MESSAGE_LENGTH),
-                     ('grpc.max_receive_message_length',
-                      tiller.MAX_MESSAGE_LENGTH)])
+            options=[
+                ('grpc.max_send_message_length', tiller.MAX_MESSAGE_LENGTH),
+                ('grpc.max_receive_message_length', tiller.MAX_MESSAGE_LENGTH)
+            ])
 
     @mock.patch('armada.handlers.tiller.K8s', autospec=True)
     @mock.patch('armada.handlers.tiller.grpc', autospec=True)
@@ -100,8 +101,8 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch.object(tiller.Tiller, '_get_tiller_pod', autospec=True)
     @mock.patch('armada.handlers.tiller.K8s', autospec=True)
     @mock.patch('armada.handlers.tiller.grpc', autospec=True)
-    def test_get_tiller_ip_with_mocked_pod(self, mock_grpc, mock_k8s,
-                                           mock_pod):
+    def test_get_tiller_ip_with_mocked_pod(
+            self, mock_grpc, mock_k8s, mock_pod):
         status = mock.Mock(pod_ip='1.1.1.1')
         mock_pod.return_value.status = status
         tiller_obj = tiller.Tiller()
@@ -110,14 +111,14 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch.object(tiller.Tiller, '_get_tiller_ip', autospec=True)
     @mock.patch('armada.handlers.tiller.K8s', autospec=True)
     @mock.patch('armada.handlers.tiller.grpc', autospec=True)
-    def test_get_tiller_pod_throws_exception(self, mock_grpc, mock_k8s,
-                                             mock_ip):
+    def test_get_tiller_pod_throws_exception(
+            self, mock_grpc, mock_k8s, mock_ip):
 
         mock_k8s.get_namespace_pod.return_value.items = []
         tiller_obj = tiller.Tiller()
         mock_grpc.insecure_channel.side_effect = ex.ChannelException()
-        self.assertRaises(ex.TillerPodNotRunningException,
-                          tiller_obj._get_tiller_pod)
+        self.assertRaises(
+            ex.TillerPodNotRunningException, tiller_obj._get_tiller_pod)
 
     @mock.patch.object(tiller.Tiller, '_get_tiller_ip', autospec=True)
     @mock.patch('armada.handlers.tiller.K8s', autospec=True)
@@ -241,22 +242,25 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch.object(tiller, 'ListReleasesRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_list_releases_paged(self, mock_stub, mock_list_releases_request,
-                                 mock_grpc, _):
+    def test_list_releases_paged(
+            self, mock_stub, mock_list_releases_request, mock_grpc, _):
         page_count = 3
         release_count = tiller.LIST_RELEASES_PAGE_SIZE * page_count
         releases = [mock.Mock() for i in range(release_count)]
         for i, release in enumerate(releases):
             release.name = mock.PropertyMock(return_value=str(i))
-        pages = [[
-            mock.Mock(
-                count=release_count,
-                total=release_count + 5,
-                next='' if i == page_count - 1 else str(
-                    (tiller.LIST_RELEASES_PAGE_SIZE * (i + 1))),
-                releases=releases[tiller.LIST_RELEASES_PAGE_SIZE *
-                                  i:tiller.LIST_RELEASES_PAGE_SIZE * (i + 1)])
-        ] for i in range(page_count)]
+        pages = [
+            [
+                mock.Mock(
+                    count=release_count,
+                    total=release_count + 5,
+                    next='' if i == page_count - 1 else str(
+                        (tiller.LIST_RELEASES_PAGE_SIZE * (i + 1))),
+                    releases=releases[tiller.LIST_RELEASES_PAGE_SIZE
+                                      * i:tiller.LIST_RELEASES_PAGE_SIZE
+                                      * (i + 1)])
+            ] for i in range(page_count)
+        ]
         mock_stub.return_value.ListReleases.side_effect = pages
 
         mock_list_releases_side_effect = [
@@ -280,8 +284,8 @@ class TillerTestCase(base.ArmadaTestCase):
 
         list_release_request_calls = [
             mock.call(
-                offset=''
-                if i == 0 else str(tiller.LIST_RELEASES_PAGE_SIZE * i),
+                offset='' if i == 0 else str(
+                    tiller.LIST_RELEASES_PAGE_SIZE * i),
                 limit=tiller.LIST_RELEASES_PAGE_SIZE,
                 status_codes=tiller.const.STATUS_ALL)
             for i in range(page_count)
@@ -292,8 +296,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch.object(tiller, 'GetReleaseContentRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_get_release_content(self, mock_release_service_stub,
-                                 mock_release_content_request, mock_grpc, _):
+    def test_get_release_content(
+            self, mock_release_service_stub, mock_release_content_request,
+            mock_grpc, _):
         mock_release_service_stub.return_value.GetReleaseContent\
             .return_value = {}
 
@@ -311,8 +316,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch.object(tiller, 'GetVersionRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_tiller_version(self, mock_release_service_stub,
-                            mock_version_request, mock_grpc, _):
+    def test_tiller_version(
+            self, mock_release_service_stub, mock_version_request, mock_grpc,
+            _):
 
         mock_version = mock.Mock()
         mock_version.Version.sem_ver = mock.sentinel.sem_ver
@@ -336,9 +342,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch.object(tiller, 'GetVersionRequest')
     @mock.patch.object(tiller, 'GetReleaseStatusRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_get_release_status(self, mock_release_service_stub,
-                                mock_rel_status_request, mock_version_request,
-                                mock_grpc, _):
+    def test_get_release_status(
+            self, mock_release_service_stub, mock_rel_status_request,
+            mock_version_request, mock_grpc, _):
         mock_release_service_stub.return_value.GetReleaseStatus. \
             return_value = {}
 
@@ -357,8 +363,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch.object(tiller, 'UninstallReleaseRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_uninstall_release(self, mock_release_service_stub,
-                               mock_uninstall_release_request, mock_grpc, _):
+    def test_uninstall_release(
+            self, mock_release_service_stub, mock_uninstall_release_request,
+            mock_grpc, _):
         mock_release_service_stub.return_value.UninstallRelease\
             .return_value = {}
 
@@ -379,8 +386,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.grpc')
     @mock.patch.object(tiller, 'RollbackReleaseRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_rollback_release(self, mock_release_service_stub,
-                              mock_rollback_release_request, _, __):
+    def test_rollback_release(
+            self, mock_release_service_stub, mock_rollback_release_request, _,
+            __):
         mock_release_service_stub.return_value.RollbackRelease\
             .return_value = {}
 
@@ -427,8 +435,9 @@ class TillerTestCase(base.ArmadaTestCase):
     @mock.patch('armada.handlers.tiller.Config')
     @mock.patch.object(tiller, 'UpdateReleaseRequest')
     @mock.patch.object(tiller, 'ReleaseServiceStub')
-    def test_update_release(self, mock_release_service_stub,
-                            mock_update_release_request, mock_config, _, __):
+    def test_update_release(
+            self, mock_release_service_stub, mock_update_release_request,
+            mock_config, _, __):
         release = 'release'
         chart = {}
         namespace = 'namespace'
@@ -507,20 +516,20 @@ class TillerTestCase(base.ArmadaTestCase):
             timeout + tiller.GRPC_EPSILON,
             metadata=tiller_obj.metadata)
 
-        expected_result = tiller.TillerResult(release, namespace, status,
-                                              description, version)
+        expected_result = tiller.TillerResult(
+            release, namespace, status, description, version)
 
         self.assertEqual(expected_result, result)
 
     def _test_test_release(self, grpc_response_mock):
-
         @mock.patch('armada.handlers.tiller.K8s')
         @mock.patch('armada.handlers.tiller.grpc')
         @mock.patch('armada.handlers.tiller.Config')
         @mock.patch.object(tiller, 'TestReleaseRequest')
         @mock.patch.object(tiller, 'ReleaseServiceStub')
-        def do_test(self, mock_release_service_stub, mock_test_release_request,
-                    mock_config, _, __):
+        def do_test(
+                self, mock_release_service_stub, mock_test_release_request,
+                mock_config, _, __):
             tiller_obj = tiller.Tiller('host', '8080', None)
             release = 'release'
             test_suite_run = {}
@@ -531,14 +540,11 @@ class TillerTestCase(base.ArmadaTestCase):
             tiller_obj.get_release_status = mock.Mock()
             tiller_obj.get_release_status.return_value = AttrDict(
                 **{
-                    'info':
-                    AttrDict(
+                    'info': AttrDict(
                         **{
-                            'status':
-                            AttrDict(
+                            'status': AttrDict(
                                 **{'last_test_suite_run': test_suite_run}),
-                            'Description':
-                            'Failed'
+                            'Description': 'Failed'
                         })
                 })
 
@@ -549,41 +555,47 @@ class TillerTestCase(base.ArmadaTestCase):
         do_test(self)
 
     def test_test_release_no_tests(self):
-        self._test_test_release([
-            AttrDict(**{
-                'msg': 'No Tests Found',
-                'status': helm.TESTRUN_STATUS_UNKNOWN
-            })
-        ])
+        self._test_test_release(
+            [
+                AttrDict(
+                    **{
+                        'msg': 'No Tests Found',
+                        'status': helm.TESTRUN_STATUS_UNKNOWN
+                    })
+            ])
 
     def test_test_release_success(self):
-        self._test_test_release([
-            AttrDict(**{
-                'msg': 'RUNNING: ...',
-                'status': helm.TESTRUN_STATUS_RUNNING
-            }),
-            AttrDict(**{
-                'msg': 'SUCCESS: ...',
-                'status': helm.TESTRUN_STATUS_SUCCESS
-            })
-        ])
+        self._test_test_release(
+            [
+                AttrDict(
+                    **{
+                        'msg': 'RUNNING: ...',
+                        'status': helm.TESTRUN_STATUS_RUNNING
+                    }),
+                AttrDict(
+                    **{
+                        'msg': 'SUCCESS: ...',
+                        'status': helm.TESTRUN_STATUS_SUCCESS
+                    })
+            ])
 
     def test_test_release_failure(self):
-        self._test_test_release([
-            AttrDict(**{
-                'msg': 'RUNNING: ...',
-                'status': helm.TESTRUN_STATUS_RUNNING
-            }),
-            AttrDict(**{
-                'msg': 'FAILURE: ...',
-                'status': helm.TESTRUN_STATUS_FAILURE
-            })
-        ])
+        self._test_test_release(
+            [
+                AttrDict(
+                    **{
+                        'msg': 'RUNNING: ...',
+                        'status': helm.TESTRUN_STATUS_RUNNING
+                    }),
+                AttrDict(
+                    **{
+                        'msg': 'FAILURE: ...',
+                        'status': helm.TESTRUN_STATUS_FAILURE
+                    })
+            ])
 
     def test_test_release_failure_to_run(self):
-
         class Iterator:
-
             def __iter__(self):
                 return self
 

armada/tests/unit/handlers/test_wait.py

@@ -23,7 +23,6 @@ test_chart = {'wait': {'timeout': 10, 'native': {'enabled': False}}}
 
 
 class ChartWaitTestCase(base.ArmadaTestCase):
-
     def get_unit(self, chart_data, timeout=None, version=2):
         chart = {
             'schema': 'armada/Chart/v{}'.format(str(version)),
@@ -118,60 +117,66 @@ class ChartWaitTestCase(base.ArmadaTestCase):
         self.assertIsInstance(unit.waits[4], wait.StatefulSetWait)
 
     def test_waits_init_min_ready_fails_if_not_controller(self):
-
         def create_pod_wait_min_ready():
-            self.get_unit({
-                'wait': {
-                    'resources': [{
-                        'type': 'pod',
-                        'labels': {
-                            'foo': 'bar'
-                        },
-                        'min_ready': 5
-                    }]
-                }
-            })
+            self.get_unit(
+                {
+                    'wait': {
+                        'resources': [
+                            {
+                                'type': 'pod',
+                                'labels': {
+                                    'foo': 'bar'
+                                },
+                                'min_ready': 5
+                            }
+                        ]
+                    }
+                })
 
-        self.assertRaises(manifest_exceptions.ManifestException,
-                          create_pod_wait_min_ready)
+        self.assertRaises(
+            manifest_exceptions.ManifestException, create_pod_wait_min_ready)
 
         def create_job_wait_min_ready():
-            self.get_unit({
-                'wait': {
-                    'resources': [{
-                        'type': 'job',
-                        'labels': {
-                            'foo': 'bar'
-                        },
-                        'min_ready': 5
-                    }]
-                }
-            })
+            self.get_unit(
+                {
+                    'wait': {
+                        'resources': [
+                            {
+                                'type': 'job',
+                                'labels': {
+                                    'foo': 'bar'
+                                },
+                                'min_ready': 5
+                            }
+                        ]
+                    }
+                })
 
-        self.assertRaises(manifest_exceptions.ManifestException,
-                          create_job_wait_min_ready)
+        self.assertRaises(
+            manifest_exceptions.ManifestException, create_job_wait_min_ready)
 
     def test_waits_init_invalid_type(self):
-
         def create_with_invalid_type():
-            self.get_unit({
-                'wait': {
-                    'resources': [{
-                        'type': 'invalid',
-                        'labels': {
-                            'foo': 'bar'
-                        },
-                        'min_ready': 5
-                    }]
-                }
-            })
+            self.get_unit(
+                {
+                    'wait': {
+                        'resources': [
+                            {
+                                'type': 'invalid',
+                                'labels': {
+                                    'foo': 'bar'
+                                },
+                                'min_ready': 5
+                            }
+                        ]
+                    }
+                })
 
-        self.assertRaises(manifest_exceptions.ManifestException,
-                          create_with_invalid_type)
+        self.assertRaises(
+            manifest_exceptions.ManifestException, create_with_invalid_type)
 
     @mock.patch.object(wait.ChartWait, 'get_resource_wait')
     def test_wait(self, get_resource_wait):
-
         def return_mock(*args, **kwargs):
             return mock.MagicMock()
 
@@ -194,7 +199,6 @@ class ChartWaitTestCase(base.ArmadaTestCase):
 
 
 class PodWaitTestCase(base.ArmadaTestCase):
-
     def get_unit(self, labels, version=2):
         return wait.PodWait(
             resource_type='pod',
@@ -202,7 +206,6 @@ class PodWaitTestCase(base.ArmadaTestCase):
             labels=labels)
 
     def test_include_resource(self):
-
         def mock_resource(annotations={}, owner_references=None):
             resource = mock.Mock()
             resource.metadata.annotations = annotations
@@ -219,10 +222,11 @@ class PodWaitTestCase(base.ArmadaTestCase):
         ]
         job_pods = [
             mock_resource(owner_references=[mock.Mock(kind='Job')]),
-            mock_resource(owner_references=[
-                mock.Mock(kind='NotAJob'),
-                mock.Mock(kind='Job')
-            ])
+            mock_resource(
+                owner_references=[
+                    mock.Mock(kind='NotAJob'),
+                    mock.Mock(kind='Job')
+                ])
         ]
         included_pods = [
             mock_resource(),
@@ -248,13 +252,11 @@ class PodWaitTestCase(base.ArmadaTestCase):
 
 
 class JobWaitTestCase(base.ArmadaTestCase):
-
     def get_unit(self, labels):
         return wait.JobWait(
             resource_type='job', chart_wait=mock.MagicMock(), labels=labels)
 
     def test_include_resource(self):
-
         def mock_resource(annotations={}, owner_references=None):
             resource = mock.Mock()
             resource.metadata.annotations = annotations
@@ -263,10 +265,11 @@ class JobWaitTestCase(base.ArmadaTestCase):
 
         cronjob_jobs = [
             mock_resource(owner_references=[mock.Mock(kind='CronJob')]),
-            mock_resource(owner_references=[
-                mock.Mock(kind='NotACronJob'),
-                mock.Mock(kind='CronJob')
-            ])
+            mock_resource(
+                owner_references=[
+                    mock.Mock(kind='NotACronJob'),
+                    mock.Mock(kind='CronJob')
+                ])
         ]
         included_jobs = [
             mock_resource(),

armada/tests/unit/utils/schema.py

@@ -18,7 +18,6 @@ from armada.utils import schema
 
 
 class SchemaTestCase(unittest.TestCase):
-
     def test_validate_load_schemas(self):
         expected_schemas = [
             'armada/Chart/v1', 'armada/ChartGroup/v1', 'armada/Manifest/v1'

armada/tests/unit/utils/test_release.py

@@ -18,7 +18,6 @@ from armada.utils import release as rel
 
 
 class ReleaseTestCase(unittest.TestCase):
-
     def test_release_prefix_pass(self):
         expected = 'armada-test'
         prefix, release = ('armada', 'test')

armada/tests/unit/utils/test_source.py

@@ -25,7 +25,6 @@ from armada.utils import source
 
 
 class GitTestCase(base.ArmadaTestCase):
-
     def _validate_git_clone(self, repo_dir, expected_ref=None):
         self.assertTrue(os.path.isdir(repo_dir))
         self.addCleanup(shutil.rmtree, repo_dir)
@@ -38,23 +37,23 @@ class GitTestCase(base.ArmadaTestCase):
                     as git_file:
                 self.assertIn(expected_ref, git_file.read())
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_good_url(self):
         url = 'https://opendev.org/airship/armada.git'
         git_dir = source.git_clone(url)
         self._validate_git_clone(git_dir)
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_commit(self):
         url = 'https://opendev.org/airship/armada.git'
         commit = 'cba78d1d03e4910f6ab1691bae633c5bddce893d'
         git_dir = source.git_clone(url, commit)
         self._validate_git_clone(git_dir, commit)
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_ref(self):
         ref = 'refs/changes/54/457754/73'
         git_dir = source.git_clone(
@@ -62,29 +61,29 @@ class GitTestCase(base.ArmadaTestCase):
         self._validate_git_clone(git_dir, ref)
 
     @test_utils.attr(type=['negative'])
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_empty_url(self):
         url = ''
         # error_re = '%s is not a valid git repository.' % url
 
-        self.assertRaises(source_exceptions.GitException, source.git_clone,
-                          url)
+        self.assertRaises(
+            source_exceptions.GitException, source.git_clone, url)
 
     @test_utils.attr(type=['negative'])
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_bad_url(self):
         url = 'https://opendev.org/dummy/armada'
 
-        self.assertRaises(source_exceptions.GitException, source.git_clone,
-                          url)
+        self.assertRaises(
+            source_exceptions.GitException, source.git_clone, url)
 
     # TODO need to design a positive proxy test,
     #      difficult to achieve behind a corporate proxy
     @test_utils.attr(type=['negative'])
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     def test_git_clone_fake_proxy(self):
         url = 'https://opendev.org/airship/armada.git'
         proxy_url = test_utils.rand_name(
@@ -140,14 +139,15 @@ class GitTestCase(base.ArmadaTestCase):
         mock_path.exists.return_value = False
         path = '/tmp/armada'
 
-        self.assertRaises(source_exceptions.InvalidPathException,
-                          source.extract_tarball, path)
+        self.assertRaises(
+            source_exceptions.InvalidPathException, source.extract_tarball,
+            path)
 
         mock_tarfile.open.assert_not_called()
         mock_tarfile.extractall.assert_not_called()
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     @mock.patch.object(source, 'LOG')
     def test_source_cleanup(self, mock_log):
         url = 'https://opendev.org/airship/armada.git'
@@ -159,8 +159,8 @@ class GitTestCase(base.ArmadaTestCase):
     @mock.patch.object(source, 'LOG')
     @mock.patch('armada.utils.source.shutil')
     @mock.patch('armada.utils.source.os.path')
-    def test_source_cleanup_missing_git_path(self, mock_path, mock_shutil,
-                                             mock_log):
+    def test_source_cleanup_missing_git_path(
+            self, mock_path, mock_shutil, mock_log):
         # Verify that passing in a missing path does nothing but log a warning.
         mock_path.exists.return_value = False
         path = 'armada'
@@ -169,11 +169,11 @@ class GitTestCase(base.ArmadaTestCase):
         mock_shutil.rmtree.assert_not_called()
         self.assertTrue(mock_log.warning.called)
         actual_call = mock_log.warning.mock_calls[0][1]
-        self.assertEqual(('Could not find the chart path %s to delete.', path),
-                         actual_call)
+        self.assertEqual(
+            ('Could not find the chart path %s to delete.', path), actual_call)
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     @test_utils.attr(type=['negative'])
     @mock.patch.object(source, 'os')
     def test_git_clone_ssh_auth_method_fails_auth(self, mock_os):
@@ -187,8 +187,8 @@ class GitTestCase(base.ArmadaTestCase):
             ref='refs/changes/17/388517/5',
             auth_method='SSH')
 
-    @testtools.skipUnless(base.is_connected(),
-                          'git clone requires network connectivity.')
+    @testtools.skipUnless(
+        base.is_connected(), 'git clone requires network connectivity.')
     @test_utils.attr(type=['negative'])
     @mock.patch.object(source, 'os')
     def test_git_clone_ssh_auth_method_missing_ssh_key(self, mock_os):

armada/tests/unit/utils/test_validate.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 
 import os
-import yaml
 
 import testtools
+import yaml
 
 from armada.tests.unit import base
 from armada.utils import validate
@@ -67,7 +67,6 @@ data:
 
 
 class BaseValidateTest(base.ArmadaTestCase):
-
     def setUp(self):
         super(BaseValidateTest, self).setUp()
         self.basepath = os.path.join(os.path.dirname(__file__), os.pardir)
@@ -110,7 +109,6 @@ class ValidateOwnExamplesTestCase(BaseValidateTest):
 
 
 class ValidateTestCase(BaseValidateTest):
-
     def test_validate_armada_yaml_passes(self):
         template = '{}/resources/valid_armada_document.yaml'.format(
             self.basepath)
@@ -215,12 +213,11 @@ data:
 
 
 class ValidateNegativeTestCase(BaseValidateTest):
-
     def test_validate_no_dictionary_expect_type_error(self):
         expected_error = 'The provided input "invalid" must be a dictionary.'
-        self.assertRaisesRegexp(TypeError, expected_error,
-                                validate.validate_armada_documents,
-                                ['invalid'])
+        self.assertRaisesRegexp(
+            TypeError, expected_error, validate.validate_armada_documents,
+            ['invalid'])
 
     def test_validate_invalid_chart_armada_manifest(self):
         template = '{}/resources/valid_armada_document.yaml'.format(