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/test_cms.py (6685B)

#    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 errno
import os
import subprocess

import mock
import testresources
from testtools import matchers

from keystoneclient.common import cms
from keystoneclient import exceptions
from keystoneclient.tests.unit import client_fixtures
from keystoneclient.tests.unit import utils

class CMSTest(utils.TestCase, testresources.ResourcedTestCase):

"""Unit tests for the keystoneclient.common.cms module."""

resources = [('examples', client_fixtures.EXAMPLES_RESOURCE)]

def __init__(self, *args, **kwargs):
        super(CMSTest, self).__init__(*args, **kwargs)
        process = subprocess.Popen(['openssl', 'version'],
                                   stdout=subprocess.PIPE)
        out, err = process.communicate()
        # Example output: 'OpenSSL 0.9.8za 5 Jun 2014'
        openssl_version = out.split()[1]

if err or openssl_version.startswith(b'0'):
            raise Exception('Your version of OpenSSL is not supported. '
                            'You will need to update it to 1.0 or later.')

def test_cms_verify(self):
        self.assertRaises(exceptions.CertificateConfigError,
                          cms.cms_verify,
                          'data',
                          'no_exist_cert_file',
                          'no_exist_ca_file')

def test_token_tocms_to_token(self):
        with open(os.path.join(client_fixtures.CMSDIR,
                               'auth_token_scoped.pem')) as f:
            AUTH_TOKEN_SCOPED_CMS = f.read()

self.assertEqual(cms.token_to_cms(self.examples.SIGNED_TOKEN_SCOPED),
                         AUTH_TOKEN_SCOPED_CMS)

tok = cms.cms_to_token(cms.token_to_cms(
            self.examples.SIGNED_TOKEN_SCOPED))
        self.assertEqual(tok, self.examples.SIGNED_TOKEN_SCOPED)

def test_asn1_token(self):
        self.assertTrue(cms.is_asn1_token(self.examples.SIGNED_TOKEN_SCOPED))
        self.assertFalse(cms.is_asn1_token('FOOBAR'))

def test_cms_sign_token_no_files(self):
        self.assertRaises(subprocess.CalledProcessError,
                          cms.cms_sign_token,
                          self.examples.TOKEN_SCOPED_DATA,
                          '/no/such/file', '/no/such/key')

def test_cms_sign_token_no_files_pkiz(self):
        self.assertRaises(subprocess.CalledProcessError,
                          cms.pkiz_sign,
                          self.examples.TOKEN_SCOPED_DATA,
                          '/no/such/file', '/no/such/key')

def test_cms_sign_token_success(self):
        self.assertTrue(
            cms.pkiz_sign(self.examples.TOKEN_SCOPED_DATA,
                          self.examples.SIGNING_CERT_FILE,
                          self.examples.SIGNING_KEY_FILE))

def test_cms_verify_token_no_files(self):
        self.assertRaises(exceptions.CertificateConfigError,
                          cms.cms_verify,
                          self.examples.SIGNED_TOKEN_SCOPED,
                          '/no/such/file', '/no/such/key')

def test_cms_verify_token_no_oserror(self):
        def raise_OSError(*args):
            e = OSError()
            e.errno = errno.EPIPE
            raise e

with mock.patch('subprocess.Popen.communicate', new=raise_OSError):
            try:
                cms.cms_verify("x", '/no/such/file', '/no/such/key')
            except exceptions.CertificateConfigError as e:
                self.assertIn('/no/such/file', e.output)
                self.assertIn('Hit OSError ', e.output)
            else:
                self.fail('Expected exceptions.CertificateConfigError')

def test_cms_verify_token_scoped(self):
        cms_content = cms.token_to_cms(self.examples.SIGNED_TOKEN_SCOPED)
        self.assertTrue(cms.cms_verify(cms_content,
                                       self.examples.SIGNING_CERT_FILE,
                                       self.examples.SIGNING_CA_FILE))

def test_cms_verify_token_scoped_expired(self):
        cms_content = cms.token_to_cms(
            self.examples.SIGNED_TOKEN_SCOPED_EXPIRED)
        self.assertTrue(cms.cms_verify(cms_content,
                                       self.examples.SIGNING_CERT_FILE,
                                       self.examples.SIGNING_CA_FILE))

def test_cms_verify_token_unscoped(self):
        cms_content = cms.token_to_cms(self.examples.SIGNED_TOKEN_UNSCOPED)
        self.assertTrue(cms.cms_verify(cms_content,
                                       self.examples.SIGNING_CERT_FILE,
                                       self.examples.SIGNING_CA_FILE))

def test_cms_verify_token_v3_scoped(self):
        cms_content = cms.token_to_cms(self.examples.SIGNED_v3_TOKEN_SCOPED)
        self.assertTrue(cms.cms_verify(cms_content,
                                       self.examples.SIGNING_CERT_FILE,
                                       self.examples.SIGNING_CA_FILE))

def test_cms_hash_token_no_token_id(self):
        token_id = None
        self.assertThat(cms.cms_hash_token(token_id), matchers.Is(None))

def test_cms_hash_token_not_pki(self):
        """If the token_id is not a PKI token then it returns the token_id."""
        token = 'something'
        self.assertFalse(cms.is_asn1_token(token))
        self.assertThat(cms.cms_hash_token(token), matchers.Is(token))

def test_cms_hash_token_default_md5(self):
        """The default hash method is md5."""
        token = self.examples.SIGNED_TOKEN_SCOPED
        token_id_default = cms.cms_hash_token(token)
        token_id_md5 = cms.cms_hash_token(token, mode='md5')
        self.assertThat(token_id_default, matchers.Equals(token_id_md5))
        # md5 hash is 32 chars.
        self.assertThat(token_id_default, matchers.HasLength(32))

def test_cms_hash_token_sha256(self):
        """Can also hash with sha256."""
        token = self.examples.SIGNED_TOKEN_SCOPED
        token_id = cms.cms_hash_token(token, mode='sha256')
        # sha256 hash is 64 chars.
        self.assertThat(token_id, matchers.HasLength(64))

def load_tests(loader, tests, pattern):
    return testresources.OptimisingTestSuite(tests)

cmd: