def attributes(self):
        result = {}

        for attribute in self.base_attributes:
            attr = getattr(self, camelcase_to_underscores(attribute))
            result[attribute] = attr

        if self.fifo_queue:
            for attribute in self.fifo_attributes:
                attr = getattr(self, camelcase_to_underscores(attribute))
                result[attribute] = attr

        if self.kms_master_key_id:
            for attribute in self.kms_attributes:
                attr = getattr(self, camelcase_to_underscores(attribute))
                result[attribute] = attr

        if self.policy:
            result['Policy'] = self.policy

        if self.redrive_policy:
            result['RedrivePolicy'] = json.dumps(self.redrive_policy)

        for key in result:
            if isinstance(result[key], bool):
                result[key] = str(result[key]).lower()

        return result

def test_camelcase_to_underscores():
    cases = {
        "theNewAttribute": "the_new_attribute",
        "attri bute With Space": "attribute_with_space",
        "FirstLetterCapital": "first_letter_capital",
    }
    for arg, expected in cases.items():
        camelcase_to_underscores(arg).should.equal(expected)

 def set_queue_attributes(self):
     queue_name = self._get_queue_name()
     if "Attribute.Name" in self.querystring:
         key = camelcase_to_underscores(self.querystring.get("Attribute.Name")[0])
         value = self.querystring.get("Attribute.Value")[0]
         self.sqs_backend.set_queue_attribute(queue_name, key, value)
     for a in self._get_list_prefix("Attribute"):
         key = camelcase_to_underscores(a["name"])
         value = a["value"]
         self.sqs_backend.set_queue_attribute(queue_name, key, value)
     return SET_QUEUE_ATTRIBUTE_RESPONSE

 def set_queue_attributes(self):
     # TODO validate self.get_param('QueueUrl')
     queue_name = self._get_queue_name()
     for key, value in self.attribute.items():
         key = camelcase_to_underscores(key)
         self.sqs_backend.set_queue_attribute(queue_name, key, value)
     return SET_QUEUE_ATTRIBUTE_RESPONSE

 def _get_dict_param(self, param_prefix):
     return {
         camelcase_to_underscores(key.replace(param_prefix, "")): value[0]
         for key, value
         in self.querystring.items()
         if key.startswith(param_prefix)
     }

 def dispatch(self):
     endpoint = self.get_endpoint_name(self.headers)
     if endpoint:
         endpoint = camelcase_to_underscores(endpoint)
         return getattr(self, endpoint)(self.uri, self.method, self.body, self.headers)
     else:
         return "", dict(status=404)

 def describe_vpc_attribute(self):
     vpc_id = self.querystring.get('VpcId')[0]
     attribute = self.querystring.get('Attribute')[0]
     attr_name = camelcase_to_underscores(attribute)
     value = self.ec2_backend.describe_vpc_attribute(vpc_id, attr_name)
     template = self.response_template(DESCRIBE_VPC_ATTRIBUTE_RESPONSE)
     return template.render(vpc_id=vpc_id, attribute=attribute, value=value)

    def call_action(self):
        headers = self.response_headers
        action = self.querystring.get('Action', [""])[0]
        if not action:  # Some services use a header for the action
            # Headers are case-insensitive. Probably a better way to do this.
            match = self.headers.get(
                'x-amz-target') or self.headers.get('X-Amz-Target')
            if match:
                action = match.split(".")[-1]

        action = camelcase_to_underscores(action)
        method_names = method_names_from_class(self.__class__)
        if action in method_names:
            method = getattr(self, action)
            try:
                response = method()
            except HTTPException as http_error:
                response = http_error.description, dict(status=http_error.code)
            if isinstance(response, six.string_types):
                return 200, headers, response
            else:
                body, new_headers = response
                status = new_headers.get('status', 200)
                headers.update(new_headers)
                # Cast status to string
                if "status" in headers:
                    headers['status'] = str(headers['status'])
                return status, headers, body

        raise NotImplementedError(
            "The {0} action has not been implemented".format(action))

    def call_action(self):
        headers = self.response_headers
        action = camelcase_to_underscores(self._get_action())
        method_names = method_names_from_class(self.__class__)
        if action in method_names:
            method = getattr(self, action)
            try:
                response = method()
            except HTTPException as http_error:
                response = http_error.description, dict(status=http_error.code)

            if isinstance(response, six.string_types):
                return 200, headers, response
            else:
                if len(response) == 2:
                    body, new_headers = response
                else:
                    status, new_headers, body = response
                status = new_headers.get('status', 200)
                headers.update(new_headers)
                # Cast status to string
                if "status" in headers:
                    headers['status'] = str(headers['status'])
                return status, headers, body

        if not action:
            return 404, headers, ''

        raise NotImplementedError(
            "The {0} action has not been implemented".format(action))

 def describe_instance_attribute(self):
     # TODO this and modify below should raise IncorrectInstanceState if instance not in stopped state
     attribute = self.querystring.get("Attribute")[0]
     key = camelcase_to_underscores(attribute)
     instance_id = self.instance_ids[0]
     instance, value = ec2_backend.describe_instance_attribute(instance_id, key)
     template = Template(EC2_DESCRIBE_INSTANCE_ATTRIBUTE)
     return template.render(instance=instance, attribute=attribute, value=value)

 def attributes(self):
     result = {}
     for attribute in self.camelcase_attributes:
         attr = getattr(self, camelcase_to_underscores(attribute))
         if isinstance(attr, bool):
             attr = str(attr).lower()
         result[attribute] = attr
     return result

    def modify_vpc_attribute(self):
        vpc_id = self.querystring.get('VpcId')[0]

        for attribute in ('EnableDnsSupport', 'EnableDnsHostnames'):
            if self.querystring.get('%s.Value' % attribute):
                attr_name = camelcase_to_underscores(attribute)
                attr_value = self.querystring.get('%s.Value' % attribute)[0]
                self.ec2_backend.modify_vpc_attribute(vpc_id, attr_name, attr_value)
                return MODIFY_VPC_ATTRIBUTE_RESPONSE

    def modify_instance_attribute(self):
        for key, value in self.querystring.iteritems():
            if ".Value" in key:
                break

        value = self.querystring.get(key)[0]
        normalized_attribute = camelcase_to_underscores(key.split(".")[0])
        instance_id = self.instance_ids[0]
        ec2_backend.modify_instance_attribute(instance_id, normalized_attribute, value)
        return EC2_MODIFY_INSTANCE_ATTRIBUTE

    def modify_subnet_attribute(self):
        subnet_id = self._get_param('SubnetId')

        for attribute in ('MapPublicIpOnLaunch', 'AssignIpv6AddressOnCreation'):
            if self.querystring.get('%s.Value' % attribute):
                attr_name = camelcase_to_underscores(attribute)
                attr_value = self.querystring.get('%s.Value' % attribute)[0]
                self.ec2_backend.modify_subnet_attribute(
                    subnet_id, attr_name, attr_value)
                return MODIFY_SUBNET_ATTRIBUTE_RESPONSE

 def to_full_dict(self):
     hsh = {
         "typeInfo": self.to_medium_dict(),
         "configuration": {}
     }
     if self.task_list:
         hsh["configuration"]["defaultTaskList"] = {"name": self.task_list}
     for key in self._configuration_keys:
         attr = camelcase_to_underscores(key)
         if not getattr(self, attr):
             continue
         hsh["configuration"][key] = getattr(self, attr)
     return hsh

 def _get_list_prefix(self, param_prefix):
     results = []
     param_index = 1
     while True:
         index_prefix = "{0}.{1}.".format(param_prefix, param_index)
         new_items = {}
         for key, value in self.querystring.items():
             if key.startswith(index_prefix):
                 new_items[camelcase_to_underscores(key.replace(index_prefix, ""))] = value[0]
         if not new_items:
             break
         results.append(new_items)
         param_index += 1
     return results

    def set_topic_attributes(self):
        topic_arn = self._get_param('TopicArn')
        attribute_name = self._get_param('AttributeName')
        attribute_name = camelcase_to_underscores(attribute_name)
        attribute_value = self._get_param('AttributeValue')
        self.backend.set_topic_attribute(topic_arn, attribute_name, attribute_value)

        return json.dumps({
            "SetTopicAttributesResponse": {
                "ResponseMetadata": {
                    "RequestId": "a8763b99-33a7-11df-a9b7-05d48da6f042"
                }
            }
        })

    def call_action(self):
        self.body = json.loads(self.body or '{}')
        endpoint = self.get_endpoint_name(self.headers)
        if endpoint:
            endpoint = camelcase_to_underscores(endpoint)
            response = getattr(self, endpoint)()
            if isinstance(response, six.string_types):
                return 200, self.response_headers, response

            else:
                status_code, new_headers, response_content = response
                self.response_headers.update(new_headers)
                return status_code, self.response_headers, response_content
        else:
            return 404, self.response_headers, ""

    def describe_instance_attribute(self):
        # TODO this and modify below should raise IncorrectInstanceState if
        # instance not in stopped state
        attribute = self.querystring.get("Attribute")[0]
        key = camelcase_to_underscores(attribute)
        instance_ids = instance_ids_from_querystring(self.querystring)
        instance_id = instance_ids[0]
        instance, value = self.ec2_backend.describe_instance_attribute(instance_id, key)

        if key == "group_set":
            template = self.response_template(EC2_DESCRIBE_INSTANCE_GROUPSET_ATTRIBUTE)
        else:
            template = self.response_template(EC2_DESCRIBE_INSTANCE_ATTRIBUTE)

        return template.render(instance=instance, attribute=attribute, value=value)

 def __init__(self, name, version, **kwargs):
     self.name = name
     self.version = version
     self.status = "REGISTERED"
     if "description" in kwargs:
         self.description = kwargs.pop("description")
     for key, value in kwargs.items():
         self.__setattr__(key, value)
     # default values set to none
     for key in self._configuration_keys:
         attr = camelcase_to_underscores(key)
         if not hasattr(self, attr):
             self.__setattr__(attr, None)
     if not hasattr(self, "task_list"):
         self.task_list = None