431 lines
19 KiB
Python
431 lines
19 KiB
Python
# Copyright 2017 The Armada Authors.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# 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
|
|
import os
|
|
import yaml
|
|
|
|
import testtools
|
|
|
|
from armada import const
|
|
from armada import exceptions
|
|
from armada.handlers import manifest
|
|
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')
|
|
with open(os.path.join(examples_dir, 'keystone-manifest.yaml')) as f:
|
|
self.documents = list(yaml.safe_load_all(f.read()))
|
|
|
|
def test_get_documents(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
|
|
self.assertIsInstance(armada_manifest.charts, list)
|
|
self.assertIsInstance(armada_manifest.groups, list)
|
|
self.assertIsNotNone(armada_manifest.manifest)
|
|
|
|
self.assertEqual(4, len(armada_manifest.charts))
|
|
self.assertEqual(2, len(armada_manifest.groups))
|
|
|
|
self.assertEqual([self.documents[x] for x in range(4)],
|
|
armada_manifest.charts)
|
|
self.assertEqual([self.documents[x] for x in range(4, 6)],
|
|
armada_manifest.groups)
|
|
self.assertEqual(self.documents[-1], armada_manifest.manifest)
|
|
|
|
def test_get_documents_with_target_manifest(self):
|
|
# Validate that specifying `target_manifest` flag returns the correct
|
|
# manifest.
|
|
armada_manifest = manifest.Manifest(
|
|
self.documents, target_manifest='armada-manifest')
|
|
|
|
self.assertIsInstance(armada_manifest.charts, list)
|
|
self.assertIsInstance(armada_manifest.groups, list)
|
|
self.assertIsNotNone(armada_manifest.manifest)
|
|
|
|
self.assertEqual(4, len(armada_manifest.charts))
|
|
self.assertEqual(2, len(armada_manifest.groups))
|
|
|
|
self.assertEqual([self.documents[x] for x in range(4)],
|
|
armada_manifest.charts)
|
|
self.assertEqual([self.documents[x] for x in range(4, 6)],
|
|
armada_manifest.groups)
|
|
self.assertEqual(self.documents[-1], armada_manifest.manifest)
|
|
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
|
|
# manifest even if there are multiple existing manifests. (Only works
|
|
# when the manifest names are distinct or else should raise error.)
|
|
documents = copy.deepcopy(self.documents)
|
|
other_manifest = copy.deepcopy(self.documents[-1])
|
|
other_manifest['metadata']['name'] = 'alt-armada-manifest'
|
|
documents.append(other_manifest)
|
|
|
|
# Specify the "original" manifest and verify it works.
|
|
armada_manifest = manifest.Manifest(
|
|
documents, target_manifest='armada-manifest')
|
|
|
|
self.assertIsInstance(armada_manifest.charts, list)
|
|
self.assertIsInstance(armada_manifest.groups, list)
|
|
self.assertIsNotNone(armada_manifest.manifest)
|
|
|
|
self.assertEqual(4, len(armada_manifest.charts))
|
|
self.assertEqual(2, len(armada_manifest.groups))
|
|
|
|
self.assertEqual([self.documents[x] for x in range(4)],
|
|
armada_manifest.charts)
|
|
self.assertEqual([self.documents[x] for x in range(4, 6)],
|
|
armada_manifest.groups)
|
|
self.assertEqual(armada_manifest.manifest, self.documents[-1])
|
|
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'])
|
|
|
|
def test_get_manifest(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
obtained_manifest = armada_manifest.get_manifest()
|
|
self.assertIsInstance(obtained_manifest, dict)
|
|
self.assertEqual(obtained_manifest['armada'],
|
|
armada_manifest.manifest['data'])
|
|
|
|
def test_find_documents(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
chart_documents, chart_groups, manifests = armada_manifest. \
|
|
_find_documents()
|
|
|
|
# checking if all the chart documents are present
|
|
self.assertIsInstance(chart_documents, list)
|
|
|
|
helm_toolkit_chart = armada_manifest. \
|
|
find_chart_document('helm-toolkit')
|
|
self.assertEqual(chart_documents[0], helm_toolkit_chart)
|
|
|
|
mariadb_chart = armada_manifest.find_chart_document('mariadb')
|
|
self.assertEqual(chart_documents[1], mariadb_chart)
|
|
|
|
memcached_chart = armada_manifest.find_chart_document('memcached')
|
|
self.assertEqual(chart_documents[2], memcached_chart)
|
|
|
|
keystone_chart = armada_manifest.find_chart_document('keystone')
|
|
self.assertEqual(chart_documents[3], keystone_chart)
|
|
|
|
# checking if all the chart group documents are present
|
|
self.assertIsInstance(chart_groups, list)
|
|
|
|
keystone_infra_services_chart_group = armada_manifest. \
|
|
find_chart_group_document('keystone-infra-services')
|
|
self.assertEqual(chart_groups[0], keystone_infra_services_chart_group)
|
|
|
|
openstack_keystone_chart_group = armada_manifest. \
|
|
find_chart_group_document('openstack-keystone')
|
|
self.assertEqual(chart_groups[1], openstack_keystone_chart_group)
|
|
|
|
# verifying the manifests
|
|
self.assertIsInstance(manifests, list)
|
|
|
|
self.assertEqual(manifests[0], armada_manifest.manifest)
|
|
|
|
def test_verify_chart_documents(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
helm_toolkit_chart = armada_manifest. \
|
|
find_chart_document('helm-toolkit')
|
|
self.assertIsInstance(helm_toolkit_chart, dict)
|
|
self.assertEqual(self.documents[0], helm_toolkit_chart)
|
|
|
|
mariadb_chart = armada_manifest.find_chart_document('mariadb')
|
|
self.assertIsInstance(mariadb_chart, dict)
|
|
self.assertEqual(self.documents[1], mariadb_chart)
|
|
|
|
memcached_chart = armada_manifest.find_chart_document('memcached')
|
|
self.assertIsInstance(memcached_chart, dict)
|
|
self.assertEqual(self.documents[2], memcached_chart)
|
|
|
|
keystone_chart = armada_manifest.find_chart_document('keystone')
|
|
self.assertIsInstance(keystone_chart, dict)
|
|
self.assertEqual(self.documents[3], keystone_chart)
|
|
|
|
def test_verify_chart_group_documents(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
ok_chart = armada_manifest. \
|
|
find_chart_group_document('openstack-keystone')
|
|
self.assertIsInstance(ok_chart, dict)
|
|
self.assertEqual(self.documents[-2], ok_chart)
|
|
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
kis_chart = armada_manifest.find_chart_group_document(
|
|
'keystone-infra-services')
|
|
self.assertIsInstance(kis_chart, dict)
|
|
self.assertEqual(self.documents[-3], kis_chart)
|
|
|
|
def test_verify_build_armada_manifest(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
|
|
built_armada_manifest = armada_manifest.build_armada_manifest()
|
|
|
|
self.assertIsNotNone(built_armada_manifest)
|
|
self.assertIsInstance(built_armada_manifest, dict)
|
|
|
|
# the first chart group in the Armada manifest
|
|
keystone_infra_services_chart_group = armada_manifest. \
|
|
find_chart_group_document('keystone-infra-services')
|
|
keystone_infra_services_chart_group_data = \
|
|
keystone_infra_services_chart_group.get('data')
|
|
|
|
self.assertEqual(keystone_infra_services_chart_group_data,
|
|
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')
|
|
openstack_keystone_chart_group_data = \
|
|
openstack_keystone_chart_group.get('data')
|
|
|
|
self.assertEqual(openstack_keystone_chart_group_data,
|
|
built_armada_manifest['data']['chart_groups'][1])
|
|
|
|
def test_verify_build_chart_group_deps(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
# building the deps for openstack-keystone chart group
|
|
chart_group = armada_manifest.find_chart_group_document(
|
|
'openstack-keystone')
|
|
openstack_keystone_chart_group_deps = armada_manifest. \
|
|
build_chart_group(chart_group)
|
|
openstack_keystone_chart_group_deps_dep_added = \
|
|
openstack_keystone_chart_group_deps[
|
|
'data']['chart_group'][0]['chart']['dependencies']
|
|
|
|
# keystone chart dependencies
|
|
keystone_chart = armada_manifest.find_chart_document('keystone')
|
|
keystone_chart_with_deps = armada_manifest.build_chart_deps(
|
|
keystone_chart)
|
|
keystone_dependencies = keystone_chart_with_deps['data'][
|
|
'dependencies']
|
|
|
|
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(
|
|
'keystone-infra-services')
|
|
openstack_keystone_chart_group_deps = armada_manifest. \
|
|
build_chart_group(chart_group)
|
|
keystone_infra_services_dep_added = \
|
|
openstack_keystone_chart_group_deps[
|
|
'data']['chart_group'][0]['chart']['dependencies']
|
|
|
|
# building mariadb chart dependencies
|
|
mariadb_chart = armada_manifest.find_chart_document('mariadb')
|
|
mariadb_chart_with_deps = armada_manifest.build_chart_deps(
|
|
mariadb_chart)
|
|
mariadb_dependencies = mariadb_chart_with_deps['data']['dependencies']
|
|
|
|
# building memcached chart dependencies
|
|
memcached_chart = armada_manifest.find_chart_document('memcached')
|
|
memcached_chart_with_deps = armada_manifest.build_chart_deps(
|
|
memcached_chart)
|
|
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])
|
|
|
|
def test_verify_build_chart_deps(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
|
|
# helm-toolkit chart
|
|
helm_toolkit_chart = armada_manifest.find_chart_document(
|
|
'helm-toolkit')
|
|
helm_toolkit_original_dependency = helm_toolkit_chart.get('data')
|
|
helm_toolkit_chart_with_deps = armada_manifest.build_chart_deps(
|
|
helm_toolkit_chart).get('data')
|
|
|
|
# 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)
|
|
|
|
# helm-toolkit dependency, the basis for comparison of d
|
|
# ependencies in other charts
|
|
expected_helm_toolkit_dependency = {
|
|
'chart': helm_toolkit_chart.get('data')
|
|
}
|
|
|
|
# keystone chart dependencies
|
|
keystone_chart = armada_manifest.find_chart_document('keystone')
|
|
original_keystone_chart = copy.deepcopy(keystone_chart)
|
|
keystone_chart_with_deps = armada_manifest.build_chart_deps(
|
|
keystone_chart)
|
|
|
|
self.assertNotEqual(original_keystone_chart, keystone_chart_with_deps)
|
|
self.assertIn('data', keystone_chart_with_deps)
|
|
self.assertIn('dependencies', keystone_chart_with_deps['data'])
|
|
|
|
keystone_dependencies = keystone_chart_with_deps['data'][
|
|
'dependencies']
|
|
self.assertIsInstance(keystone_dependencies, list)
|
|
self.assertEqual(1, len(keystone_dependencies))
|
|
|
|
self.assertEqual(expected_helm_toolkit_dependency,
|
|
keystone_dependencies[0])
|
|
|
|
# mariadb chart dependencies
|
|
mariadb_chart = armada_manifest.find_chart_document('mariadb')
|
|
original_mariadb_chart = copy.deepcopy(mariadb_chart)
|
|
mariadb_chart_with_deps = armada_manifest.build_chart_deps(
|
|
mariadb_chart)
|
|
|
|
self.assertNotEqual(original_mariadb_chart, mariadb_chart_with_deps)
|
|
self.assertIn('data', mariadb_chart_with_deps)
|
|
self.assertIn('dependencies', mariadb_chart_with_deps['data'])
|
|
|
|
mariadb_dependencies = mariadb_chart_with_deps['data']['dependencies']
|
|
self.assertIsInstance(mariadb_dependencies, list)
|
|
self.assertEqual(1, len(mariadb_dependencies))
|
|
|
|
self.assertEqual(expected_helm_toolkit_dependency,
|
|
mariadb_dependencies[0])
|
|
|
|
# memcached chart dependencies
|
|
memcached_chart = armada_manifest.find_chart_document('memcached')
|
|
original_memcached_chart = copy.deepcopy(memcached_chart)
|
|
memcached_chart_with_deps = armada_manifest.build_chart_deps(
|
|
memcached_chart)
|
|
|
|
self.assertNotEqual(original_memcached_chart,
|
|
memcached_chart_with_deps)
|
|
self.assertIn('data', memcached_chart_with_deps)
|
|
self.assertIn('dependencies', memcached_chart_with_deps['data'])
|
|
|
|
memcached_dependencies = memcached_chart_with_deps['data'][
|
|
'dependencies']
|
|
self.assertIsInstance(memcached_dependencies, list)
|
|
self.assertEqual(1, len(memcached_dependencies))
|
|
|
|
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')
|
|
with open(os.path.join(examples_dir, 'keystone-manifest.yaml')) as f:
|
|
self.documents = list(yaml.safe_load_all(f.read()))
|
|
|
|
def test_get_documents_multi_manifests_raises_value_error(self):
|
|
# Validates that finding multiple manifests without `target_manifest`
|
|
# flag raises exceptions.ManifestException.
|
|
documents = copy.deepcopy(self.documents)
|
|
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)
|
|
|
|
def test_get_documents_multi_target_manifests_raises_value_error(self):
|
|
# Validates that finding multiple manifests with `target_manifest`
|
|
# flag raises exceptions.ManifestException.
|
|
documents = copy.deepcopy(self.documents)
|
|
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,
|
|
target_manifest='armada-manifest')
|
|
|
|
def test_get_documents_missing_manifest(self):
|
|
# Validates exceptions.ManifestException is thrown if no manifest is
|
|
# found. Manifest is last document in sample YAML.
|
|
error_re = ('Documents must be a list of documents with at least one '
|
|
'of each of the following schemas: .*')
|
|
self.assertRaisesRegexp(exceptions.ManifestException, error_re,
|
|
manifest.Manifest, self.documents[:-1])
|
|
|
|
def test_get_documents_missing_charts(self):
|
|
# Validates exceptions.ManifestException is thrown if no chart is
|
|
# found. Charts are first 4 documents in sample YAML.
|
|
error_re = ('Documents must be a list of documents with at least one '
|
|
'of each of the following schemas: .*')
|
|
self.assertRaisesRegexp(exceptions.ManifestException, error_re,
|
|
manifest.Manifest, self.documents[4:])
|
|
|
|
def test_get_documents_missing_chart_groups(self):
|
|
# Validates exceptions.ManifestException is thrown if no chart is
|
|
# found. ChartGroups are 5-6 documents in sample YAML.
|
|
documents = self.documents[:4] + [self.documents[-1]]
|
|
error_re = ('Documents must be a list of documents with at least one '
|
|
'of each of the following schemas: .*')
|
|
self.assertRaisesRegexp(exceptions.ManifestException, error_re,
|
|
manifest.Manifest, documents)
|
|
|
|
def test_find_chart_document_negative(self):
|
|
armada_manifest = manifest.Manifest(self.documents)
|
|
error_re = r'Could not find a %s named "%s"' % (const.DOCUMENT_CHART,
|
|
'invalid')
|
|
self.assertRaisesRegexp(exceptions.ManifestException, 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 a %s named "%s"' % (const.DOCUMENT_GROUP,
|
|
'invalid')
|
|
self.assertRaisesRegexp(exceptions.ManifestException, 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
|
|
a missing dependency fails.
|
|
"""
|
|
self.documents[1]['data']['dependencies'] = ['missing-dependency']
|
|
valid, details = validate.validate_armada_documents(self.documents)
|
|
self.assertFalse(valid)
|
|
|
|
def test_build_chart_group_with_missing_chart_grp_fails(self):
|
|
"""Validate that attempting to build a chart group document with
|
|
missing chart group fails.
|
|
"""
|
|
self.documents[5]['data']['chart_group'] = ['missing-chart-group']
|
|
valid, details = validate.validate_armada_documents(self.documents)
|
|
self.assertFalse(valid)
|
|
|
|
def test_build_armada_manifest_with_missing_chart_grps_fails(self):
|
|
"""Validate that attempting to build a manifest with missing
|
|
chart groups fails.
|
|
"""
|
|
self.documents[6]['data']['chart_groups'] = ['missing-chart-groups']
|
|
valid, details = validate.validate_armada_documents(self.documents)
|
|
self.assertFalse(valid)
|