FM / unit

/usr/lib/python2.6/site-packages/keystoneclient/tests/unit/

/usr/lib/python2.6/site-packages/keystoneclient/tests/unit

Name	Size	Mode	Actions
apiclient/	-	0755	rm
auth/	-	0755	rm
generic/	-	0755	rm
v2_0/	-	0755	rm
v3/	-	0755	rm
client_fixtures.py	26336	0644	edit dl rm
client_fixtures.pyc	16152	0644	edit dl rm
test_auth_token_middleware.py	79955	0644	edit dl rm
test_auth_token_middleware.pyc	86384	0644	edit dl rm
test_base.py	6500	0644	edit dl rm
test_base.pyc	7522	0644	edit dl rm
test_cms.py	6685	0644	edit dl rm
test_cms.pyc	8265	0644	edit dl rm
test_discovery.py	30195	0644	edit dl rm
test_discovery.pyc	31073	0644	edit dl rm
test_ec2utils.py	11898	0644	edit dl rm
test_ec2utils.pyc	9985	0644	edit dl rm
test_fixtures.py	9885	0644	edit dl rm
test_fixtures.pyc	8562	0644	edit dl rm
test_hacking_checks.py	1870	0644	edit dl rm
test_hacking_checks.pyc	2353	0644	edit dl rm
test_http.py	8299	0644	edit dl rm
test_http.pyc	9113	0644	edit dl rm
test_https.py	4186	0644	edit dl rm
test_https.pyc	4044	0644	edit dl rm
test_keyring.py	8150	0644	edit dl rm
test_keyring.pyc	7186	0644	edit dl rm
test_memcache_crypt.py	4342	0644	edit dl rm
test_memcache_crypt.pyc	4593	0644	edit dl rm
test_s3_token_middleware.py	11203	0644	edit dl rm
test_s3_token_middleware.pyc	12989	0644	edit dl rm
test_session.py	37718	0644	edit dl rm
test_session.pyc	43512	0644	edit dl rm
test_shell.py	24297	0644	edit dl rm
test_shell.pyc	21318	0644	edit dl rm
test_utils.py	8431	0644	edit dl rm
test_utils.pyc	12435	0644	edit dl rm
utils.py	6840	0644	edit dl rm
utils.pyc	8917	0644	edit dl rm
__init__.py	0	0644	edit dl rm
__init__.pyc	168	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/keystoneclient/tests/unit/utils.py (6840B)

#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import logging
import sys
import uuid

import fixtures
from oslo_serialization import jsonutils
import requests
from requests_mock.contrib import fixture
import six
from six.moves.urllib import parse as urlparse
import testtools

from keystoneclient.tests.unit import client_fixtures

class TestCase(testtools.TestCase):

TEST_DOMAIN_ID = uuid.uuid4().hex
    TEST_DOMAIN_NAME = uuid.uuid4().hex
    TEST_GROUP_ID = uuid.uuid4().hex
    TEST_ROLE_ID = uuid.uuid4().hex
    TEST_TENANT_ID = uuid.uuid4().hex
    TEST_TENANT_NAME = uuid.uuid4().hex
    TEST_TOKEN = uuid.uuid4().hex
    TEST_TRUST_ID = uuid.uuid4().hex
    TEST_USER = uuid.uuid4().hex
    TEST_USER_ID = uuid.uuid4().hex

TEST_ROOT_URL = 'http://127.0.0.1:5000/'

def setUp(self):
        super(TestCase, self).setUp()
        self.deprecations = self.useFixture(client_fixtures.Deprecations())

self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
        self.requests_mock = self.useFixture(fixture.Fixture())

def stub_url(self, method, parts=None, base_url=None, json=None, **kwargs):
        if not base_url:
            base_url = self.TEST_URL

if json:
            kwargs['text'] = jsonutils.dumps(json)
            headers = kwargs.setdefault('headers', {})
            headers['Content-Type'] = 'application/json'

if parts:
            url = '/'.join([p.strip('/') for p in [base_url] + parts])
        else:
            url = base_url

url = url.replace("/?", "?")
        self.requests_mock.register_uri(method, url, **kwargs)

def assertRequestBodyIs(self, body=None, json=None):
        last_request_body = self.requests_mock.last_request.body
        if json:
            val = jsonutils.loads(last_request_body)
            self.assertEqual(json, val)
        elif body:
            self.assertEqual(body, last_request_body)

def assertQueryStringIs(self, qs=''):
        """Verify the QueryString matches what is expected.

The qs parameter should be of the format \'foo=bar&abc=xyz\'
        """
        expected = urlparse.parse_qs(qs, keep_blank_values=True)
        parts = urlparse.urlparse(self.requests_mock.last_request.url)
        querystring = urlparse.parse_qs(parts.query, keep_blank_values=True)
        self.assertEqual(expected, querystring)

def assertQueryStringContains(self, **kwargs):
        """Verify the query string contains the expected parameters.

This method is used to verify that the query string for the most recent
        request made contains all the parameters provided as ``kwargs``, and
        that the value of each parameter contains the value for the kwarg. If
        the value for the kwarg is an empty string (''), then all that's
        verified is that the parameter is present.

"""
        parts = urlparse.urlparse(self.requests_mock.last_request.url)
        qs = urlparse.parse_qs(parts.query, keep_blank_values=True)

for k, v in six.iteritems(kwargs):
            self.assertIn(k, qs)
            self.assertIn(v, qs[k])

def assertRequestHeaderEqual(self, name, val):
        """Verify that the last request made contains a header and its value

The request must have already been made.
        """
        headers = self.requests_mock.last_request.headers
        self.assertEqual(headers.get(name), val)

if tuple(sys.version_info)[0:2] < (2, 7):

def assertDictEqual(self, d1, d2, msg=None):
        # Simple version taken from 2.7
        self.assertIsInstance(d1, dict,
                              'First argument is not a dictionary')
        self.assertIsInstance(d2, dict,
                              'Second argument is not a dictionary')
        if d1 != d2:
            if msg:
                self.fail(msg)
            else:
                standardMsg = '%r != %r' % (d1, d2)
                self.fail(standardMsg)

TestCase.assertDictEqual = assertDictEqual

class TestResponse(requests.Response):
    """Class used to wrap requests.Response and provide some
       convenience to initialize with a dict.
    """

def __init__(self, data):
        self._text = None
        super(TestResponse, self).__init__()
        if isinstance(data, dict):
            self.status_code = data.get('status_code', 200)
            headers = data.get('headers')
            if headers:
                self.headers.update(headers)
            # Fake the text attribute to streamline Response creation
            # _content is defined by requests.Response
            self._content = data.get('text')
        else:
            self.status_code = data

def __eq__(self, other):
        return self.__dict__ == other.__dict__

@property
    def text(self):
        return self.content

class DisableModuleFixture(fixtures.Fixture):
    """A fixture to provide support for unloading/disabling modules."""

def __init__(self, module, *args, **kw):
        super(DisableModuleFixture, self).__init__(*args, **kw)
        self.module = module
        self._finders = []
        self._cleared_modules = {}

def tearDown(self):
        super(DisableModuleFixture, self).tearDown()
        for finder in self._finders:
            sys.meta_path.remove(finder)
        sys.modules.update(self._cleared_modules)

def clear_module(self):
        cleared_modules = {}
        for fullname in list(sys.modules):
            if (fullname == self.module or
                    fullname.startswith(self.module + '.')):
                cleared_modules[fullname] = sys.modules.pop(fullname)
        return cleared_modules

def setUp(self):
        """Ensure ImportError for the specified module."""

super(DisableModuleFixture, self).setUp()

# Clear 'module' references in sys.modules
        self._cleared_modules.update(self.clear_module())

finder = NoModuleFinder(self.module)
        self._finders.append(finder)
        sys.meta_path.insert(0, finder)

class NoModuleFinder(object):
    """Disallow further imports of 'module'."""

def __init__(self, module):
        self.module = module

def find_module(self, fullname, path):
        if fullname == self.module or fullname.startswith(self.module + '.'):
            raise ImportError

cmd: