def test_double_service_registration(self):
        service1 = HelloService()
        service2 = HelloService()

        StackInABox.register_service(service1)
        with self.assertRaises(ServiceAlreadyRegisteredError):
            StackInABox.register_service(service2)

def registration(uri):
    """Responses handler registration.

    Registers a handler for a given URI with Responses
    so that it can be intercepted and handed to
    Stack-In-A-Box.

    :param uri: URI used for the base of the HTTP requests

    :returns: n/a
    """

    # log the URI that is used to access the Stack-In-A-Box services
    logger.debug('Registering Stack-In-A-Box at {0} under Python Responses'
                 .format(uri))
    # tell Stack-In-A-Box what URI to match with
    StackInABox.update_uri(uri)

    # Build the regex for the URI and register all HTTP verbs
    # with Responses
    regex = re.compile('(http)?s?(://)?{0}:?(\d+)?/'.format(uri),
                       re.I)
    METHODS = [
        responses.DELETE,
        responses.GET,
        responses.HEAD,
        responses.OPTIONS,
        responses.PATCH,
        responses.POST,
        responses.PUT
    ]
    for method in METHODS:
        responses.add_callback(method,
                               regex,
                               callback=responses_callback)

 def setUp(self):
     super(TestKeystoneV2UserGet, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.tokens.admin_token
     }
     StackInABox.register_service(self.keystone)

 def setUp(self):
     super(TestKeystoneV2UserAddCredentials, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.tokens.admin_token
     }
     self.tenant_id = self.keystone.model.tenants.add(
         tenant_name='neo',
         description='The One'
     )
     self.user_info = {
         'user': {
             'username': 'trinity',
             'enabled': True,
             'email': '[email protected]',
             'password': 'Inl0veWithNeo'
         }
     }
     self.user_info['user']['userid'] = self.keystone.model.users.add(
         tenant_id=self.tenant_id,
         username=self.user_info['user']['username'],
         email=self.user_info['user']['email'],
         password=self.user_info['user']['password'],
         enabled=self.user_info['user']['enabled']
     )
     self.keystone.model.tokens.add(
         tenant_id=self.tenant_id,
         user_id=self.user_info['user']['userid']
     )
     self.keystone.model.roles.add_user_role_by_role_name(
         tenant_id=self.tenant_id,
         user_id=self.user_info['user']['userid'],
         role_name=self.keystone.model.roles.IDENTITY_ADMIN_ROLE
     )
     StackInABox.register_service(self.keystone)

 def setUp(self):
     super(TestKeystoneV2UserListing, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.get_admin_token()
     }
     StackInABox.register_service(self.keystone)

 def setUp(self):
     super(TestKeystoneV2UserUpdate, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.tokens.admin_token
     }
     self.tenant_id = self.keystone.model.tenants.add(
         tenant_name='neo',
         description='The One'
     )
     self.user_info = {
         'user': {
             'username': 'trinity',
             'enabled': True,
             'email': '[email protected]',
             'OS-KSADM:password': 'Inl0veWithNeo'
         }
     }
     self.user_info['user']['userid'] = self.keystone.model.users.add(
         tenant_id=self.tenant_id,
         username=self.user_info['user']['username'],
         email=self.user_info['user']['email'],
         password=self.user_info['user']['OS-KSADM:password'],
         enabled=self.user_info['user']['enabled']
     )
     self.keystone.model.tokens.add(
         tenant_id=self.tenant_id,
         user_id=self.user_info['user']['userid']
     )
     StackInABox.register_service(self.keystone)

 def setUp(self):
     super(TestHttprettyKeystone, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.tokens.admin_token
     }
     StackInABox.register_service(self.keystone)
     self.session = requests.Session()

    def test_service_exception(self):
        exceptional = ExceptionalServices()
        StackInABox.register_service(exceptional)

        stackinabox.util_httpretty.httpretty_registration('localhost')

        res = requests.get('http://localhost/except/')
        self.assertEqual(res.status_code, 596)

    def run():
        StackInABox.reset_services()
        StackInABox.register_service(HelloService())
        stackinabox.util.responses.registration('localhost')

        res = requests.get('http://localhost/hello/')
        assert res.status_code == 200
        assert res.text == 'Hello'

    def test_subservice_registration(self):
        service = AnotherAdvancedService()
        subservice = YetAnotherService()
        service.register_subservice(re.compile('^/french'),
                                    subservice)

        StackInABox.register_service(service)

        stackinabox.util_httpretty.httpretty_registration('localhost')

        res = requests.get('http://localhost/aas/french')
        self.assertEqual(res.status_code,
                         200)
        self.assertEqual(res.text,
                         'bonjour')

 def setUp(self):
     super(TestKeystoneV2UserAdd, self).setUp()
     self.keystone = KeystoneV2Service()
     self.headers = {
         'x-auth-token': self.keystone.model.get_admin_token()
     }
     self.user_info = {
         'user': {
             'username': 'trinity',
             'enabled': True,
             'email': '[email protected]',
             'OS-KSADM:password': 'Inl0veWithNeo'
         }
     }
     StackInABox.register_service(self.keystone)

def httpretty_callback(request, uri, headers):
    """httpretty request handler.

    converts a call intercepted by httpretty to
    the stack-in-a-box infrastructure

    :param request: request object
    :param uri: the uri of the request
    :param headers: headers for the response

    :returns: tuple - (int, dict, string) containing:
                      int - the http response status code
                      dict - the headers for the http response
                      string - http string response

    """
    method = request.method
    response_headers = CaseInsensitiveDict()
    response_headers.update(headers)
    request_headers = CaseInsensitiveDict()
    request_headers.update(request.headers)
    request.headers = request_headers
    return StackInABox.call_into(method,
                                 request,
                                 uri,
                                 response_headers)

def httpretty_registration(uri):

    status_data = {
        595: 'StackInABoxService - Unknown Route',
        596: 'StackInABox - Exception in Service Handler',
        597: 'StackInABox - Unknown Service'
    }
    for k, v in six.iteritems(status_data):
        if k not in httpretty.http.STATUSES:
            httpretty.http.STATUSES[k] = v

    logger.debug('Registering Stack-In-A-Box at {0} under Python HTTPretty'
                 .format(uri))
    StackInABox.update_uri(uri)
    regex = re.compile('(http)?s?(://)?{0}:?(\d+)?/'.format(uri),
                       re.I)
    for method in HttpBaseClass.METHODS:
        register_uri(method, regex, body=httpretty_callback)

def requests_mock_session_registration(uri, session):
    logger.debug('Registering Stack-In-A-Box at {0} under Python Requests-Mock'
                 .format(uri))
    logger.debug('Session has id {0}'.format(id(session)))

    StackInABox.update_uri(uri)
    StackInABox.hold_onto('adapter', requests_mock.Adapter())
    StackInABox.hold_out('adapter').add_matcher(RequestMockCallable(uri))

    session.mount('http://{0}'.format(uri), StackInABox.hold_out('adapter'))
    session.mount('https://{0}'.format(uri), StackInABox.hold_out('adapter'))

    def handle(self, request, uri):
        """Request handler interface.

        :param request: Python requests Request object
        :param uri: URI of the request
        """

        # Convert the call over to Stack-In-A-Box
        method = request.method
        headers = CaseInsensitiveDict()
        request_headers = CaseInsensitiveDict()
        request_headers.update(request.headers)
        request.headers = request_headers
        stackinabox_result = StackInABox.call_into(method,
                                                   request,
                                                   uri,
                                                   headers)

        # reformat the result for easier use
        status_code, output_headers, body = stackinabox_result

        json_data = None
        text_data = None
        content_data = None
        body_data = None

        # if the body is a string-type...
        if isinstance(body, six.string_types):
            # Try to convert it to JSON
            text_data = body
            try:
                json_data = json.dumps(text_data)
                text_data = json_data
            except Exception:
                json_data = None
                text_data = body

        # if the body is binary, then it's the content
        elif isinstance(body, six.binary_type):
            content_data = body

        # by default, it's just body data
        else:
            # default to body data
            body_data = body

        # build the Python requests' Response object
        return requests_mock.response.create_response(
            request,
            headers=output_headers,
            status_code=status_code,
            body=body_data,
            json=json_data,
            text=text_data,
            content=content_data
        )

def responses_registration(uri):
    logger.debug('Registering Stack-In-A-Box at {0} under Python Responses'
                 .format(uri))
    StackInABox.update_uri(uri)
    regex = re.compile('(http)?s?(://)?{0}:?(\d+)?/'.format(uri),
                       re.I)
    METHODS = [
        responses.DELETE,
        responses.GET,
        responses.HEAD,
        responses.OPTIONS,
        responses.PATCH,
        responses.POST,
        responses.PUT
    ]
    for method in METHODS:
        responses.add_callback(method,
                               regex,
                               callback=responses_callback)

def httpretty_callback(request, uri, headers):
    method = request.method
    response_headers = CaseInsensitiveDict()
    response_headers.update(headers)
    request_headers = CaseInsensitiveDict()
    request_headers.update(request.headers)
    request.headers = request_headers
    return StackInABox.call_into(method,
                                 request,
                                 uri,
                                 response_headers)

def responses_callback(request):
    method = request.method
    headers = CaseInsensitiveDict()
    request_headers = CaseInsensitiveDict()
    request_headers.update(request.headers)
    request.headers = request_headers
    uri = request.url
    return StackInABox.call_into(method,
                                 request,
                                 uri,
                                 headers)

    def setUp(self):
        super(TestKeystoneV2AuthBase, self).setUp()

        self.tenantname = self.make_tenant_name()
        self.keystone = KeystoneV2Service()
        self.username = 'user_{0}'.format(str(uuid.uuid4()))
        self.password = 'pAss{0}'.format(
            str(uuid.uuid4()).replace('-', '')
        )
        self.apikey = str(uuid.uuid4())
        self.email = '{0}@stackinabox.mock'.format(self.username)
        self.keystone.model.tenants.add(
            tenant_name=self.tenantname,
            description="test tenant"
        )
        tenant_data = self.keystone.model.tenants.get_by_name(
            tenant_name=self.tenantname
        )
        self.tenantid = tenant_data['id']

        self.keystone.model.users.add(
            tenant_id=self.tenantid,
            username=self.username,
            password=self.password,
            apikey=self.apikey,
            email=self.email
        )
        user_data = self.keystone.model.users.get_by_name(
            tenant_id=self.tenantid,
            username=self.username
        )
        self.userid = user_data['user_id']
        self.token = self.keystone.model.tokens.make_token()
        self.keystone.model.tokens.add(
            tenant_id=self.tenantid,
            user_id=self.userid,
            token=self.token
        )

        StackInABox.register_service(self.keystone)

        def wrapped(*args, **kwargs):
            args_copy = list(args)
            for arg in self.args:
                args_copy.append(arg)
            args_finalized = tuple(args_copy)
            kwargs.update(self.kwargs)

            if self.enable_service_access is not None:
                kwargs[self.enable_service_access] = self.services

            httpretty.reset()
            httpretty.enable()

            for service in self.services.values():
                StackInABox.register_service(service)
            httpretty_registration(self.uri)
            return_value = fn(*args_finalized, **kwargs)
            StackInABox.reset_services()

            httpretty.disable()
            httpretty.reset()

            return return_value