def __init__(self, region_name=None):
self.region_name = region_name
self.resolver_endpoints = {} # Key is self-generated ID (endpoint_id)
self.resolver_rules = {} # Key is self-generated ID (rule_id)
self.resolver_rule_associations = {
} # Key is resolver_rule_association_id)
self.tagger = TaggingService()
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.resolver_endpoints = {} # Key is self-generated ID (endpoint_id)
self.resolver_rules = {} # Key is self-generated ID (rule_id)
self.resolver_rule_associations = {
} # Key is resolver_rule_association_id)
self.tagger = TaggingService()
def test_create_tag_without_value():
svc = TaggingService()
tags = [{"Key": "key_key"}]
svc.tag_resource("arn", tags)
actual = svc.list_tags_for_resource("arn")
expected = {"Tags": [{"Key": "key_key", "Value": None}]}
expected.should.be.equal(actual)
def test_create_tag():
svc = TaggingService("TheTags", "TagKey", "TagValue")
tags = [{"TagKey": "key_key", "TagValue": "value_value"}]
svc.tag_resource("arn", tags)
actual = svc.list_tags_for_resource("arn")
expected = {"TheTags": [{"TagKey": "key_key", "TagValue": "value_value"}]}
expected.should.be.equal(actual)
def test_delete_tag_using_tags():
svc = TaggingService()
tags = [{"Key": "key_key", "Value": "value_value"}]
svc.tag_resource("arn", tags)
svc.untag_resource_using_tags("arn", tags)
result = svc.list_tags_for_resource("arn")
{"Tags": []}.should.be.equal(result)
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.creation_tokens = set()
self.access_points = dict()
self.file_systems_by_id = {}
self.mount_targets_by_id = {}
self.next_markers = {}
self.tagging_service = TaggingService()
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.distributions = dict()
self.tagger = TaggingService()
state_manager.register_default_transition(
"cloudfront::distribution", transition={"progression": "manual", "times": 1}
)
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self._clusters = dict()
self._tagger = TaggingService()
state_manager.register_default_transition(
model_name="dax::cluster", transition={"progression": "manual", "times": 4}
)
def test_delete_all_tags_for_resource():
svc = TaggingService()
tags = [{"Key": "key_key", "Value": "value_value"}]
tags2 = [{"Key": "key_key2", "Value": "value_value2"}]
svc.tag_resource("arn", tags)
svc.tag_resource("arn", tags2)
svc.delete_all_tags_for_resource("arn")
result = svc.list_tags_for_resource("arn")
{"Tags": []}.should.be.equal(result)
def __init__(self, region_name):
self.rules = {}
# This array tracks the order in which the rules have been added, since
# 2.6 doesn't have OrderedDicts.
self.rules_order = []
self.next_tokens = {}
self.region_name = region_name
self.event_buses = {}
self.event_sources = {}
self.tagger = TaggingService()
self._add_default_event_bus()
def test_extract_tag_names():
svc = TaggingService()
tags = [{
"Key": "key1",
"Value": "value1"
}, {
"Key": "key2",
"Value": "value2"
}]
actual = svc.extract_tag_names(tags)
expected = ["key1", "key2"]
expected.should.be.equal(actual)
def test_copy_non_existing_arn():
svc = TaggingService()
tags = [{
"Key": "key1",
"Value": "value1"
}, {
"Key": "key2",
"Value": "value2"
}]
svc.tag_resource("new_arn", tags)
#
svc.copy_tags("non_existing_arn", "new_arn")
# Copying from a non-existing ARN should a NOOP
# Assert the old tags still exist
actual = sorted(svc.list_tags_for_resource("new_arn")["Tags"],
key=lambda t: t["Key"])
actual.should.equal(tags)
def test_copy_existing_arn():
svc = TaggingService()
tags_old_arn = [{"Key": "key1", "Value": "value1"}]
tags_new_arn = [{"Key": "key2", "Value": "value2"}]
svc.tag_resource("old_arn", tags_old_arn)
svc.tag_resource("new_arn", tags_new_arn)
#
svc.copy_tags("old_arn", "new_arn")
# Assert the old tags still exist
actual = sorted(svc.list_tags_for_resource("new_arn")["Tags"],
key=lambda t: t["Key"])
actual.should.equal([{
"Key": "key1",
"Value": "value1"
}, {
"Key": "key2",
"Value": "value2"
}])
def __init__(self, region):
self.region = region
self.keys = {}
self.key_to_aliases = defaultdict(set)
self.tagger = TaggingService(key_name="TagKey", value_name="TagValue")
def __init__(self, region_name=None):
self.region_name = region_name
self.delivery_streams = {}
self.tagger = TaggingService()
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.apps = {}
self.tagger = TaggingService()
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.databases = dict()
self.tagging_service = TaggingService()
def __init__(self, region_name=None):
self.region_name = region_name
self.operations = dict()
self.namespaces = dict()
self.services = dict()
self.tagger = TaggingService()
def test_list_empty_delete():
svc = TaggingService()
svc.untag_resource_using_names("arn", ["key_key"])
result = svc.list_tags_for_resource("arn")
{"Tags": []}.should.be.equal(result)
def __init__(self, region_name=None):
self.region_name = region_name
self.graphql_apis = dict()
self.tagger = TaggingService()
def __init__(self, region_name):
self.region_name = region_name
self._clusters = dict()
self._tagger = TaggingService()
def __init__(self, region_name, account_id=None):
super().__init__(region_name=region_name, account_id=account_id)
self.keys = {}
self.key_to_aliases = defaultdict(set)
self.tagger = TaggingService(key_name="TagKey", value_name="TagValue")
def __init__(self, region_name=None):
self.region_name = region_name
self.directories = {}
self.tagger = TaggingService()
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.graphql_apis = dict()
self.tagger = TaggingService()
def __init__(self, region_name):
self.region_name = region_name
self.registry_policy = None
self.replication_config = {"rules": []}
self.repositories: Dict[str, Repository] = {}
self.tagger = TaggingService(tag_name="tags")
def __init__(self, region_name, account_id):
super().__init__(region_name, account_id)
self.delivery_streams = {}
self.tagger = TaggingService()
def __init__(self):
self.keys = {}
self.key_to_aliases = defaultdict(set)
self.tagger = TaggingService(keyName="TagKey", valueName="TagValue")
def test_list_empty():
svc = TaggingService()
result = svc.list_tags_for_resource("test")
{"Tags": []}.should.be.equal(result)
def __init__(self, region_name=None):
self.region_name = region_name
self.brokers = dict()
self.configs = dict()
self.tagger = TaggingService()
def __init__(self, region_name):
self.region_name = region_name
self.trails = dict()
self.tagging_service = TaggingService(tag_name="TagsList")