def test_make_patch_ok(self, config, k8sconfig):
"""Compute patch between two manifests.
This test function first verifies that the patch between two identical
manifests is empty. The second used two manifests that have different
labels. This must produce two patch operations, one to remove the old
label and one to add the new ones.
"""
# Two valid manifests.
kind, namespace, name = "Deployment", "namespace", "name"
srv = make_manifest(kind, namespace, name)
loc = make_manifest(kind, namespace, name)
srv["metadata"]["labels"] = {"old": "old"}
loc["metadata"]["labels"] = {"new": "new"}
# The Patch between two identical manifests must be a No-Op.
res, err = resource(k8sconfig,
MetaManifest("apps/v1", kind, namespace, name))
assert not err
expected = JsonPatch(url=res.url, ops=[])
assert sq.make_patch(config, k8sconfig, loc, loc) == (expected, False)
# The patch between `srv` and `loc` must remove the old label and add
# the new one.
expected = JsonPatch(url=res.url,
ops=[{
'op': 'remove',
'path': '/metadata/labels/old'
}, {
'op': 'add',
'path': '/metadata/labels/new',
'value': 'new'
}])
assert sq.make_patch(config, k8sconfig, loc, srv) == (expected, False)
def test_make_patch_special(self, config, k8sconfig):
"""Namespace, ClusterRole(Bindings) etc are special.
What makes them special is that they exist outside namespaces.
Therefore, they will/must not contain a `metadata.Namespace` attribute
and require special treatment in `make_patch`.
"""
for kind in ["Namespace", "ClusterRole"]:
meta = manio.make_meta(make_manifest(kind, None, "name"))
# Determine the resource path so we can verify it later.
url = resource(k8sconfig, meta)[0].url
# The patch between two identical manifests must be empty but valid.
loc = srv = make_manifest(kind, None, "name")
assert sq.make_patch(config, k8sconfig, loc,
srv) == ((url, []), False)
# Create two almost identical manifests, except the second one has
# different `metadata.labels`. This must succeed.
loc = make_manifest(kind, None, "name")
srv = copy.deepcopy(loc)
loc['metadata']['labels'] = {"key": "value"}
data, err = sq.make_patch(config, k8sconfig, loc, srv)
assert err is False and len(data) > 0
def test_make_patch_incompatible(self, config, k8sconfig):
"""Must not try to compute diffs for incompatible manifests.
For instance, refuse to compute a patch when one manifest has kind
"Namespace" and the other "Deployment". The same is true for
"apiVersion", "metadata.name" and "metadata.namespace".
"""
# Demo Deployment manifest.
srv = make_manifest('Deployment', 'Namespace', 'name')
err_resp = (JsonPatch("", []), True)
# `apiVersion` must match.
loc = copy.deepcopy(srv)
loc['apiVersion'] = 'mismatch'
assert sq.make_patch(config, k8sconfig, loc, srv) == err_resp
# `kind` must match.
loc = copy.deepcopy(srv)
loc['kind'] = 'Mismatch'
assert sq.make_patch(config, k8sconfig, loc, srv) == err_resp
# `name` must match.
loc = copy.deepcopy(srv)
loc['metadata']['name'] = 'mismatch'
assert sq.make_patch(config, k8sconfig, loc, srv) == err_resp
# `namespace` must match.
loc = copy.deepcopy(srv)
loc['metadata']['namespace'] = 'mismatch'
assert sq.make_patch(config, k8sconfig, loc, srv) == 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_make_patch_err(self, config, k8sconfig):
"""Verify error cases with invalid or incompatible manifests."""
err_resp = (JsonPatch("", []), True)
kind, namespace, name = "Deployment", "namespace", "name"
valid = make_manifest(kind, namespace, name)
# Must handle `resource` errors.
with mock.patch.object(sq.k8s, "resource") as m_url:
m_url.return_value = (None, True)
assert sq.make_patch(config, k8sconfig, valid, valid) == err_resp
# Must handle incompatible manifests, ie manifests that do not belong
# to the same resource.
valid_a = make_manifest(kind, namespace, "bar")
valid_b = make_manifest(kind, namespace, "foo")
assert sq.make_patch(config, k8sconfig, valid_a, valid_b) == err_resp
def test_make_patch_error_resource(self, m_url, config, k8sconfig):
"""Coverage gap: simulate `resource` error."""
# Simulate `resource` error.
m_url.return_value = (None, True)
# Test function must return with error.
loc = srv = make_manifest("Deployment", "ns", "foo")
assert sq.make_patch(config, k8sconfig, loc,
srv) == (JsonPatch("", []), True)
def test_make_patch_empty(self, config, k8sconfig):
"""Basic test: compute patch between two identical resources."""
# Setup.
kind, ns, name = 'Deployment', 'ns', 'foo'
# PATCH URLs require the resource name at the end of the request path.
url = resource(k8sconfig, MetaManifest("apps/v1", kind, ns,
name))[0].url
# The patch must be empty for identical manifests.
loc = srv = make_manifest(kind, ns, name)
data, err = sq.make_patch(config, k8sconfig, loc, srv)
assert (data, err) == (JsonPatch(url, []), False)
assert isinstance(data, JsonPatch)
