def test_compile_plan_err(self, m_apply, m_plan, m_part, config,
k8sconfig):
"""Use mocks for the internal function calls to simulate errors."""
err_resp = (DeploymentPlan(tuple(), tuple(), tuple()), True)
# Define a single resource and valid dummy return value for
# `sq.partition_manifests`.
meta = MetaManifest('v1', 'Namespace', None, 'ns1')
plan = DeploymentPlan(create=[], patch=[meta], delete=[])
# Local and server manifests have the same resources but their
# definition differs. This will ensure a non-empty patch in the plan.
loc_man = srv_man = {meta: make_manifest("Namespace", None, "ns1")}
# Simulate an error in `partition_manifests`.
m_part.return_value = (None, True)
assert sq.compile_plan(config, k8sconfig, loc_man, srv_man) == err_resp
# Simulate an error in `diff`.
m_part.return_value = (plan, False)
m_plan.return_value = (None, True)
assert sq.compile_plan(config, k8sconfig, loc_man, srv_man) == err_resp
# Simulate an error in `make_patch`.
m_part.return_value = (plan, False)
m_plan.return_value = ("some string", False)
m_apply.return_value = (None, True)
assert sq.compile_plan(config, k8sconfig, loc_man, srv_man) == err_resp
def test_compile_plan_create_delete_err(self, m_part, config, k8sconfig):
"""Simulate `resource` errors."""
err_resp = (DeploymentPlan(tuple(), tuple(), tuple()), True)
# Valid ManifestMeta and dummy manifest dict.
man = make_manifest("Deployment", "ns", "name")
meta = manio.make_meta(man)
man = {meta: man}
# Pretend we only have to "create" resources and then trigger the
# `resource` error in its code path.
m_part.return_value = (
DeploymentPlan(create=[meta], patch=[], delete=[]),
False,
)
# We must not be able to compile a plan because of the `resource` error.
with mock.patch.object(sq.k8s, "resource") as m_url:
m_url.return_value = (None, True)
assert sq.compile_plan(config, k8sconfig, man, man) == err_resp
# Pretend we only have to "delete" resources, and then trigger the
# `resource` error in its code path.
m_part.return_value = (
DeploymentPlan(create=[], patch=[], delete=[meta]),
False,
)
with mock.patch.object(sq.k8s, "resource") as m_url:
m_url.return_value = (None, True)
assert sq.compile_plan(config, k8sconfig, man, man) == err_resp
def test_compile_plan_patch_with_diff(self, config, k8sconfig):
"""Test a plan that patches all resources.
To do this, the local and server resources are identical. As a
result, the returned plan must nominate all manifests for patching, and
none to create and delete.
"""
# Define a single resource.
meta = MetaManifest('v1', 'Namespace', None, 'ns1')
# Local and server manifests have the same resources but their
# definition differs. This will ensure a non-empty patch in the plan.
loc_man = {meta: make_manifest("Namespace", None, "ns1")}
srv_man = {meta: make_manifest("Namespace", None, "ns1")}
loc_man[meta]["metadata"]["labels"] = {"foo": "foo"}
srv_man[meta]["metadata"]["labels"] = {"bar": "bar"}
# Compute the JSON patch and textual diff to populate the expected
# output structure below.
patch, err = sq.make_patch(config, k8sconfig, loc_man[meta],
srv_man[meta])
assert not err
diff_str, err = manio.diff(config, k8sconfig, loc_man[meta],
srv_man[meta])
assert not err
# Verify the test function returns the correct Patch and diff.
expected = DeploymentPlan(create=[],
patch=[DeltaPatch(meta, diff_str, patch)],
delete=[])
ret = sq.compile_plan(config, k8sconfig, loc_man, srv_man)
assert ret == (expected, False)
def test_compile_plan_err_strip(self, config, k8sconfig):
"""Abort if any of the manifests cannot be stripped."""
err_resp = (DeploymentPlan(tuple(), tuple(), tuple()), True)
# Create two valid `ServerManifests`, then stunt one in such a way that
# `manio.strip` will reject it.
man_valid = make_manifest("Deployment", "namespace", "name")
man_error = make_manifest("Deployment", "namespace", "name")
meta_valid = manio.make_meta(man_valid)
meta_error = manio.make_meta(man_error)
# Stunt one manifest.
del man_error["kind"]
# Compile to `ServerManifest` types.
valid = {meta_valid: man_valid}
error = {meta_error: man_error}
# Must handle errors from `manio.strip`.
assert sq.compile_plan(config, k8sconfig, valid, error) == err_resp
assert sq.compile_plan(config, k8sconfig, error, valid) == err_resp
assert sq.compile_plan(config, k8sconfig, error, error) == err_resp
def test_compile_plan_patch_no_diff(self, config, k8sconfig):
"""The plan must be empty if the local and server manifests are too."""
# Define two namespaces with 1 deployment in each.
meta = [
MetaManifest('v1', 'Namespace', None, 'ns1'),
MetaManifest('apps/v1', 'Deployment', 'ns1', 'res_0'),
MetaManifest('v1', 'Namespace', None, 'ns2'),
MetaManifest('apps/v1', 'Deployment', 'ns2', 'res_1'),
]
# Local and server manifests are identical. The plan must therefore
# only nominate patches but nothing to create or delete.
src = {_: make_manifest(_.kind, _.namespace, _.name) for _ in meta}
expected = DeploymentPlan(create=[], patch=[], delete=[])
assert sq.compile_plan(config, k8sconfig, src,
src) == (expected, False)
def test_compile_plan_invalid_api_version(self, config, k8sconfig):
"""Test a plan that patches no resources.
The local and server manifests are identical except for the API
version. The plan must still be empty because Square adapts to the
local manifests to the default API group.
"""
# Define a namespaces with an Ingress. The Ingress uses the legacy API group.
meta = [
MetaManifest("invalid", "Deployment", "ns", "name"),
]
# Local and server manifests will be identical.
src = {_: make_manifest(_.kind, _.namespace, _.name) for _ in meta}
# The plan must fail because the API group is invalid.
ret = sq.compile_plan(config, k8sconfig, src, src)
assert ret == (DeploymentPlan(tuple(), tuple(), tuple()), True)
def test_compile_plan_create_delete_ok(self, config, k8sconfig):
"""Test a plan that creates and deletes resource, but not patch any.
To do this, the local and server resources are all distinct. As a
result, the returned plan must dictate that all local resources shall
be created, all server resources deleted, and none patched.
"""
# Local: defines Namespace "ns1" with 1 deployment.
meta = [
MetaManifest('v1', 'Namespace', None, 'ns1'),
MetaManifest('apps/v1', 'Deployment', 'ns1', 'res_0'),
# Server: has a Namespace "ns2" with 2 deployments.
MetaManifest('v1', 'Namespace', None, 'ns2'),
MetaManifest('apps/v1', 'Deployment', 'ns2', 'res_1'),
MetaManifest('apps/v1', 'Deployment', 'ns2', 'res_2'),
]
# Determine the K8sResource for all involved resources. Also verify
# that all resources specify a valid API group.
res = [resource(k8sconfig, _._replace(name="")) for _ in meta]
assert not any([_[1] for _ in res])
res = [_[0] for _ in res]
# Compile local and server manifests. Their resources have no overlap.
# This will ensure that we have to create all the local resources,
# delete all the server resources, and patch nothing.
loc_man = {
_: make_manifest(_.kind, _.namespace, _.name)
for _ in meta[:2]
}
srv_man = {
_: make_manifest(_.kind, _.namespace, _.name)
for _ in meta[2:]
}
# The resources require a manifest to specify the terms of deletion.
# This is currently hard coded into the function.
del_opts = {
"apiVersion": "v1",
"kind": "DeleteOptions",
"gracePeriodSeconds": 0,
"orphanDependents": False,
}
# Resources declared in local files must be created and server resources deleted.
expected = DeploymentPlan(
create=[
DeltaCreate(meta[0], res[0].url, loc_man[meta[0]]),
DeltaCreate(meta[1], res[1].url, loc_man[meta[1]]),
],
patch=[],
delete=[
DeltaDelete(meta[2], res[2].url + "/" + meta[2].name,
del_opts),
DeltaDelete(meta[3], res[3].url + "/" + meta[3].name,
del_opts),
DeltaDelete(meta[4], res[4].url + "/" + meta[4].name,
del_opts),
],
)
ret, err = sq.compile_plan(config, k8sconfig, loc_man, srv_man)
assert ret.create == expected.create
assert (ret, err) == (expected, False)