def test_copy(self) -> None:
"""Test copy."""
obj = CfnginContext(deploy_environment=self.env)
obj_copy = obj.copy()
assert obj_copy != obj
assert obj_copy.config == obj.config
assert obj_copy.env != obj.env
def test_unlock_persistent_graph_no_such_key(
self, mocker: MockerFixture) -> None:
"""Test unlock_persistent_graph empty graph NoSuchKey."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", True)
mocker.patch.object(CfnginContext, "persistent_graph_lock_code", "123")
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict({}, context=obj)
stubber = Stubber(obj.s3_client)
stubber.add_response(
"get_object",
{"Body": "{}".encode()},
{
"ResponseContentType": "application/json",
**obj.persistent_graph_location,
},
)
stubber.add_client_error("delete_object_tagging", "NoSuchKey")
with stubber:
assert obj.unlock_persistent_graph("123")
def test_lock_persistent_graph(self, mocker: MockerFixture) -> None:
"""Test lock_persistent_graph."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", False)
mocker.patch.object(CfnginContext, "persistent_graph", True)
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_response(
"put_object_tagging",
{},
{
"Tagging": {
# pylint: disable=protected-access
"TagSet": [{
"Key": obj._persistent_graph_lock_tag,
"Value": "123"
}]
},
**obj.persistent_graph_location,
},
)
with stubber:
assert not obj.lock_persistent_graph("123")
def test_unlock_persistent_graph(self, graph_dict: Dict[str, List[str]],
mocker: MockerFixture) -> None:
"""Test unlock_persistent_graph."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", True)
mocker.patch.object(CfnginContext, "persistent_graph_lock_code", "123")
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict(graph_dict, context=obj)
stubber = Stubber(obj.s3_client)
if not graph_dict:
stubber.add_response(
"get_object",
{"Body": "{}".encode()},
{
"ResponseContentType": "application/json",
**obj.persistent_graph_location,
},
)
stubber.add_response("delete_object_tagging", {},
obj.persistent_graph_location)
with stubber:
assert obj.unlock_persistent_graph("123")
def test_persistent_graph_lock_code_none(self,
mocker: MockerFixture) -> None:
"""Test persistent_graph_lock_code None."""
mocker.patch.object(CfnginContext, "persistent_graph_location", False)
assert not CfnginContext().persistent_graph_lock_code
mocker.patch.object(CfnginContext, "persistent_graph_location", True)
mocker.patch.object(CfnginContext, "persistent_graph_tags",
{"key": "val"})
assert not CfnginContext().persistent_graph_lock_code
def test_get_fqn(self, mocker: MockerFixture) -> None:
"""Test get_fqn."""
mock_get_fqn = mocker.patch(f"{MODULE}.get_fqn",
return_value="success")
obj = CfnginContext(config=self.config)
assert obj.get_fqn("name") == "success"
mock_get_fqn.assert_called_once_with(obj.base_fqn,
self.config.namespace_delimiter,
"name")
def test_persistent_graph_tags(self, mocker: MockerFixture) -> None:
"""Test persistent_graph_tags."""
bucket = "test-bucket"
key = "persistent_graphs/test/something.json"
mocker.patch.object(CfnginContext, "persistent_graph_location", {
"Bucket": bucket,
"Key": key
})
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_response("get_object_tagging", {"TagSet": []},
obj.persistent_graph_location)
stubber.add_response(
"get_object_tagging",
{"TagSet": [{
"Key": "key",
"Value": "val"
}]},
obj.persistent_graph_location,
)
with stubber:
assert obj.persistent_graph_tags == {}
assert obj.persistent_graph_tags == {"key": "val"}
def test_persistent_graph(self, mocker: MockerFixture) -> None:
"""Test persistent_graph."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "s3_bucket_verified", True)
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_response(
"get_object",
{"Body": gen_s3_object_content(self.persist_graph_raw)},
{
"ResponseContentType": "application/json",
**obj.persistent_graph_location,
},
)
with stubber:
assert isinstance(obj.persistent_graph, Graph)
assert obj.persistent_graph.to_dict() == self.persist_graph_raw
def test_persistent_graph_no_such_key(self, mocker: MockerFixture) -> None:
"""Test persistent_graph NoSuchKey."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "s3_bucket_verified", True)
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_client_error("get_object", "NoSuchKey")
stubber.add_response(
"put_object",
{},
{
"Body": "{}".encode(),
"ServerSideEncryption": "AES256",
"ACL": "bucket-owner-full-control",
"ContentType": "application/json",
**obj.persistent_graph_location,
},
)
with stubber:
assert isinstance(obj.persistent_graph, Graph)
assert obj.persistent_graph.to_dict() == {}
def test_stacks_dict(self) -> None:
"""Test stacks_dict."""
obj = CfnginContext(config=self.config)
assert obj.stacks_dict == {
"test-stack1": obj.stacks[0],
"test-stack2": obj.stacks[1],
}
def test_tags_empty(self) -> None:
"""Test tags empty."""
obj = CfnginContext(config=CfnginConfig.parse_obj({
"namespace": "test",
"tags": {}
}))
assert obj.tags == {}
def test_tags_none(self) -> None:
"""Test tags None."""
obj = CfnginContext(config=CfnginConfig.parse_obj({
"namespace": "test",
"tags": None
}))
assert obj.tags == {"cfngin_namespace": obj.config.namespace}
def test_put_persistent_graph_empty(self, mocker: MockerFixture) -> None:
"""Test put_persistent_graph empty."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict({}, context=obj)
stubber = Stubber(obj.s3_client)
stubber.add_response("delete_object", {},
obj.persistent_graph_location)
with stubber:
assert not obj.put_persistent_graph("123")
def test_bucket_name_config(self, mocker: MockerFixture) -> None:
"""Test bucket_name from Config."""
mocker.patch.object(CfnginContext, "upload_to_s3", True)
assert (CfnginContext(
config=CfnginConfig.parse_obj({
"namespace": "test",
"cfngin_bucket": "test-bucket"
})).bucket_name == "test-bucket")
def test_stacks(self) -> None:
"""Test stacks."""
obj = CfnginContext(config=self.config)
assert len(obj.stacks) == len(self.config.stacks)
assert isinstance(obj.stacks[0], Stack)
assert obj.stacks[0].name == self.config.stacks[0].name
assert isinstance(obj.stacks[1], Stack)
assert obj.stacks[1].name == self.config.stacks[1].name
def test_namespace_delimiter(self) -> None:
"""Test namespace_delimiter."""
config = CfnginConfig.parse_obj({
"namespace": "test",
"namespace_delimiter": "."
})
assert (CfnginContext(
config=config).namespace_delimiter == config.namespace_delimiter)
def test_put_persistent_graph_not_locked(self,
mocker: MockerFixture) -> None:
"""Test put_persistent_graph not locked."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", False)
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict(self.persist_graph_raw,
context=obj)
with pytest.raises(PersistentGraphUnlocked):
obj.put_persistent_graph("123")
def test_unlock_persistent_graph_empty_no_such_key(
self, mocker: MockerFixture) -> None:
"""Test unlock_persistent_graph empty graph NoSuchKey."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict({}, context=obj)
stubber = Stubber(obj.s3_client)
stubber.add_client_error("get_object", "NoSuchKey")
with stubber:
assert obj.unlock_persistent_graph("123")
def test_unlock_persistent_graph_lock_code_mismatch(
self, mocker: MockerFixture) -> None:
"""Test unlock_persistent_graph lock code mismatch."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", True)
mocker.patch.object(CfnginContext, "persistent_graph_lock_code", "0")
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict(self.persist_graph_raw,
context=obj)
with pytest.raises(PersistentGraphCannotUnlock):
assert obj.unlock_persistent_graph("123")
def test_tags(self) -> None:
"""Test tags."""
obj = CfnginContext(config=CfnginConfig.parse_obj({
"namespace": "test",
"tags": {
"key": "val"
}
}))
assert obj.tags == obj.config.tags
def test_lock_persistent_graph_no_such_key(self,
mocker: MockerFixture) -> None:
"""Test lock_persistent_graph NoSuchKey."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", False)
mocker.patch.object(CfnginContext, "persistent_graph", True)
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_client_error("put_object_tagging", "NoSuchKey")
with stubber, pytest.raises(PersistentGraphCannotLock):
obj.lock_persistent_graph("123")
def test_s3_client(self, mocker: MockerFixture) -> None:
"""Test s3_client."""
mock_client = MagicMock()
mock_session = MagicMock(client=MagicMock(return_value=mock_client))
mock_get_session = mocker.patch.object(CfnginContext,
"get_session",
return_value=mock_session)
assert CfnginContext(
deploy_environment=self.env).s3_client == mock_client
mock_get_session.assert_called_once_with(region=self.env.aws_region)
mock_session.client.assert_called_once_with("s3")
def test_s3_bucket_verified(self, mocker: MockerFixture) -> None:
"""Test s3_bucket_verified."""
mock_ensure_s3_bucket = mocker.patch(f"{MODULE}.ensure_s3_bucket")
mocker.patch.object(CfnginContext, "bucket_name", "test-bucket")
mocker.patch.object(CfnginContext, "persistent_graph_location", {})
obj = CfnginContext()
assert obj.s3_bucket_verified is True
assert obj.s3_bucket_verified is True # value should be cached
mock_ensure_s3_bucket.assert_called_once_with(obj.s3_client,
obj.bucket_name,
obj.bucket_region,
persist_graph=False)
def test_persistent_graph_location_add_json(self) -> None:
"""Test persistent_graph_location adds `.json` extension."""
config = CfnginConfig.parse_obj({
"namespace": "test",
"cfngin_bucket": "test-bucket",
"persistent_graph_key": "something",
})
obj = CfnginContext(config=config)
assert obj.persistent_graph_location["Bucket"] == config.cfngin_bucket
assert (
obj.persistent_graph_location["Key"] ==
f"persistent_graphs/{config.namespace}/{config.persistent_graph_key}.json"
)
def test_init_defaults(self) -> None:
"""Test init defaults."""
obj = CfnginContext()
assert obj.bucket_region == self.env.aws_region
assert isinstance(obj.config, CfnginConfig)
assert obj.config.namespace == "example"
assert obj.config_path == Path.cwd()
assert isinstance(obj.env, DeployEnvironment)
assert obj.force_stacks == []
assert obj.hook_data == {}
assert obj.logger
assert obj.parameters == {}
assert obj.stack_names == []
def test_mappings(self) -> None:
"""Test mappings."""
config = CfnginConfig.parse_obj({
"namespace": "test",
"mappings": {
"my_map": {
"something": {
"key": "val"
}
}
}
})
assert CfnginContext(config=config).mappings == config.mappings
def test_get_stack(self) -> None:
"""Test get_stack."""
obj = CfnginContext(config=self.config)
assert obj.get_stack("test-stack1") == obj.stacks[0]
# namespace is added if not provided
assert obj.get_stack("stack1") == obj.stacks[0]
assert not obj.get_stack("dev-stack1")
assert not obj.get_stack("stack12")
def test_put_persistent_graph(self, mocker: MockerFixture) -> None:
"""Test put_persistent_graph."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "something.json"
},
)
mocker.patch.object(CfnginContext, "persistent_graph_locked", True)
mocker.patch.object(CfnginContext, "persistent_graph_lock_code", "123")
obj = CfnginContext()
obj.persistent_graph = Graph.from_dict(self.persist_graph_raw,
context=obj)
stubber = Stubber(obj.s3_client)
stubber.add_response(
"put_object",
{},
{
"Body":
json.dumps(self.persist_graph_raw,
default=json_serial,
indent=4).encode(),
"ServerSideEncryption":
"AES256",
"ACL":
"bucket-owner-full-control",
"ContentType":
"application/json",
"Tagging":
"cfngin_lock_code=123",
**obj.persistent_graph_location,
},
)
with stubber:
assert not obj.put_persistent_graph("123")
def test_persistent_graph_tags_no_such_key(self,
mocker: MockerFixture) -> None:
"""Test persistent_graph_tags NoSuchKey."""
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"Key": "persistent_graphs/test/something.json"
},
)
obj = CfnginContext()
stubber = Stubber(obj.s3_client)
stubber.add_client_error("get_object_tagging", "NoSuchKey")
with stubber:
assert obj.persistent_graph_tags == {}
def test_persistent_graph_s3_not_verified(self,
mocker: MockerFixture) -> None:
"""Test persistent_graph s3 not verified."""
mock_graph = mocker.patch(
f"{MODULE}.Graph",
MagicMock(from_dict=MagicMock(return_value="success")))
mocker.patch.object(
CfnginContext,
"persistent_graph_location",
{
"Bucket": "test-bucket",
"key": "something.json"
},
)
mocker.patch.object(CfnginContext, "s3_bucket_verified", False)
obj = CfnginContext()
assert obj.persistent_graph == "success"
mock_graph.from_dict.assert_called_once_with({}, obj)
