FM / unit

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

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

Name	Size	Mode	Actions
access/	-	0755	rm
data/	-	0755	rm
extras/	-	0755	rm
identity/	-	0755	rm
loading/	-	0755	rm
client_fixtures.py	4926	0644	edit dl rm
client_fixtures.pyc	3473	0644	edit dl rm
k2k_fixtures.py	5454	0644	edit dl rm
k2k_fixtures.pyc	4878	0644	edit dl rm
keystoneauth_fixtures.py	2360	0644	edit dl rm
keystoneauth_fixtures.pyc	2239	0644	edit dl rm
matchers.py	3165	0644	edit dl rm
matchers.pyc	3906	0644	edit dl rm
oidc_fixtures.py	1690	0644	edit dl rm
oidc_fixtures.pyc	1139	0644	edit dl rm
test_betamax_fixture.py	2193	0644	edit dl rm
test_betamax_fixture.pyc	2604	0644	edit dl rm
test_discovery.py	7745	0644	edit dl rm
test_discovery.pyc	6715	0644	edit dl rm
test_fixtures.py	10719	0644	edit dl rm
test_fixtures.pyc	9426	0644	edit dl rm
test_hacking_checks.py	1744	0644	edit dl rm
test_hacking_checks.pyc	2034	0644	edit dl rm
test_matchers.py	1902	0644	edit dl rm
test_matchers.pyc	1658	0644	edit dl rm
test_session.py	30260	0644	edit dl rm
test_session.pyc	32258	0644	edit dl rm
test_token_endpoint.py	2337	0644	edit dl rm
test_token_endpoint.pyc	3020	0644	edit dl rm
test_utils.py	791	0644	edit dl rm
test_utils.pyc	791	0644	edit dl rm
utils.py	4950	0644	edit dl rm
utils.pyc	6215	0644	edit dl rm
__init__.py	0	0644	edit dl rm
__init__.pyc	159	0644	edit dl rm

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

#    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 json as jsonutils
import logging
import time
import uuid

import fixtures
import mock
from mox3 import mox
import requests
from requests_mock.contrib import fixture
import six
from six.moves.urllib import parse as urlparse
import testtools

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.mox = mox.Mox()
        self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
        self.time_patcher = mock.patch.object(time, 'time', lambda: 1234)
        self.time_patcher.start()

self.requests_mock = self.useFixture(fixture.Fixture())

def tearDown(self):
        self.time_patcher.stop()
        self.mox.UnsetStubs()
        self.mox.VerifyAll()
        super(TestCase, self).tearDown()

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)

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

cmd: