示例#1
0
    def setUp(self):
        super(ShellTest, self).setUp()
        global _old_env
        _old_env, os.environ = os.environ, self.auth_env

        self.requests = self.useFixture(rm_fixture.Fixture())

        json_list = ks_fixture.DiscoveryList(DEFAULT_UNVERSIONED_AUTH_URL)
        self.requests.get(DEFAULT_IMAGE_URL, json=json_list, status_code=300)

        json_v2 = {'version': ks_fixture.V2Discovery(DEFAULT_V2_AUTH_URL)}
        self.requests.get(DEFAULT_V2_AUTH_URL, json=json_v2)

        json_v3 = {'version': ks_fixture.V3Discovery(DEFAULT_V3_AUTH_URL)}
        self.requests.get(DEFAULT_V3_AUTH_URL, json=json_v3)

        self.v2_auth = self.requests.post(DEFAULT_V2_AUTH_URL + '/tokens',
                                          json=V2_TOKEN)

        headers = {'X-Subject-Token': TOKEN_ID}
        self.v3_auth = self.requests.post(DEFAULT_V3_AUTH_URL + '/auth/tokens',
                                          headers=headers,
                                          json=V3_TOKEN)

        global shell, _shell, assert_called, assert_called_anytime
        _shell = openstack_shell.OpenStackImagesShell()
        shell = lambda cmd: _shell.main(cmd.split())
示例#2
0
    def setUp(self):
        super(TestNode, self).setUp()
        self.ecs_endpoint = 'https://127.0.0.1:4443'
        self.token_endpoint = 'https://127.0.0.1:4443/login'

        self.client = Client(
            '2',
            ecs_endpoint=self.ecs_endpoint,
            token_endpoint=self.token_endpoint,
            username='******',
            password='******'
        )

        self.returned_json = {
            "node": [
                {
                    "ip": "172.29.3.148",
                    "version": "1.2.0.0.60071.ffbe16c",
                    "rackId": "gray",
                    "nodename": "supr01-r01-01.lax01s1.rspaas-lab.ops.com",
                    "nodeid": "171.29.3.140"
                },
                {
                    "ip": "172.29.3.149",
                    "version": "1.2.0.0.60071.ffbe16c",
                    "rackId": "gray",
                    "nodename": "supr01-r01-02.lax01s1.rspaas-lab.ops.com",
                    "nodeid": "171.29.3.141"
                }
            ]
        }

        self.response = MagicMock()
        self.requests_mock = self.useFixture(fixture.Fixture())
示例#3
0
    def setUp(self):
        super(TestGrantRequest, self).setUp()
        self.requests_mock = self.useFixture(requests_mock_fixture.Fixture())
        self.url = "http://nfvo.co.jp/grant/v1/grants"
        self.nfvo_url = 'http://nfvo.co.jp'
        self.headers = {'content-type': 'application/json'}

        self.token_endpoint = 'https://oauth2/tokens'
        self.nfvo_url = 'http://nfvo.co.jp'
        self.oauth_url = 'https://oauth2'
        self.auth_user_name = 'test_user'
        self.auth_password = '******'

        cfg.CONF.set_override('auth_type', None,
                              group='authentication')
        cfg.CONF.set_override("base_url", self.url, group='connect_grant')
        cfg.CONF.set_override('user_name', self.auth_user_name,
                              group='authentication')
        cfg.CONF.set_override('password', self.auth_password,
                              group='authentication')
        cfg.CONF.set_override('token_endpoint', self.token_endpoint,
                              group='authentication')
        cfg.CONF.set_override('client_id', self.auth_user_name,
                              group='authentication')
        cfg.CONF.set_override('client_password', self.auth_password,
                              group='authentication')
        auth.auth_manager = auth._AuthManager()
        nfvo_client.GrantRequest._connector = nfvo_client._Connect(2, 1, 20)
示例#4
0
 def setUp(self):
     super(SaltLocalActionTestCase, self).setUp()
     self.m = self.useFixture(fixture.Fixture())
     self.action = self.get_action_instance(config=CONFIG_DATA)
     self.m.register_uri('POST',
                         "{}/run".format(CONFIG_DATA['api_url']),
                         json={})
示例#5
0
 def setUp(self):
     super(FixturedTestCase, self).setUp()
     if self.client_fixture_class:
         self.requests_mock = self.useFixture(
             requests_mock_fixture.Fixture())
         fix = self.client_fixture_class(self.requests_mock)
         self.cs = self.useFixture(fix).client
示例#6
0
    def setUp(self):
        super(TestClient, self).setUp()
        self.mock = self.useFixture(fixture.Fixture())

        self.endpoint = 'http://example.com:9292'
        self.ssl_endpoint = 'https://example.com:9292'
        self.client = http.HTTPClient(self.endpoint, token=u'abc123')
示例#7
0
    def setUp(self):
        super(DefaultAuthPluginTests, self).setUp()

        self.stream = six.StringIO()
        self.logger = logging.getLogger(__name__)
        self.session = session.Session()
        self.requests_mock = self.useFixture(rm_fixture.Fixture())
示例#8
0
    def setUp(self):
        super(DynECTTestsCase, self).setUp()
        self.target = objects.PoolTarget.from_dict({
            'id':
            '4588652b-50e7-46b9-b688-a9bad40a873e',
            'type':
            'dyndns',
            'masters': [{
                'host': '192.0.2.1',
                'port': 53
            }],
            'options': [{
                'key': 'username',
                'value': 'example'
            }, {
                'key': 'password',
                'value': 'secret'
            }, {
                'key': 'customer_name',
                'value': 'customer'
            }],
        })

        self.backend = impl_dynect.DynECTBackend(self.target)
        self.requests = self.useFixture(req_fixture.Fixture())
    def setUp(self):
        super(SCCITestCase, self).setUp()

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

        with open(os.path.join(
                os.path.dirname(__file__),
                'fixtures/irmc_report_ok.xml'), "r") as report_ok:
            self.report_ok_txt = report_ok.read()
        self.report_ok_xml = ET.fromstring(self.report_ok_txt)

        with open(os.path.join(
                os.path.dirname(__file__),
                'fixtures/irmc_report_ng.xml'), "r") as report_ng:
            self.report_ng_txt = report_ng.read()
        self.report_ng_xml = ET.fromstring(self.report_ng_txt)

        self.irmc_address = '10.124.196.159'
        self.irmc_username = '******'
        self.irmc_password = '******'
        self.irmc_port = 80
        self.irmc_auth_method = 'basic'
        self.irmc_client_timeout = 60

        self.irmc_remote_image_server = '10.33.110.49'
        self.irmc_remote_image_user_domain = 'example.local'
        self.irmc_remote_image_share_type = scci.ShareType.nfs
        self.irmc_remote_image_share_name = 'share'
        self.irmc_remote_image_deploy_iso = 'ubuntu-14.04.1-server-amd64.iso'
        self.irmc_remote_image_username = '******'
        self.irmc_remote_image_user_password = '******'
示例#10
0
    def setUp(self):
        super(BaseTest, self).setUp()
        self.requests_fixture = self.useFixture(requests_fixture.Fixture())
        self.config_fixture = self.useFixture(config_fixture.Config(conf=CONF))
        self.session_fixture = self.useFixture(SessionFixture())
        self.db_fixture = self.useFixture(DatabaseFixture(conf=CONF))
        self.app = app.test_client()

        self.service_providers = {
            'default': {
                'image_endpoint': 'http://images.local',
                'volume_endpoint': 'http://volumes.local'
            },
            'remote1': {
                'image_endpoint': 'http://images.remote1',
                'volume_endpoint': 'http://volumes.remote1'
            },
        }

        # set config values
        self.config_fixture.load_raw_values(
            service_providers='default, remote1', aggregation=True)
        self.config_fixture.load_raw_values(
            group='sp_default',
            image_endpoint='http://images.local',
            volume_endpoint='http://volumes.local')
        self.config_fixture.load_raw_values(
            group='sp_remote1',
            image_endpoint='http://images.remote1',
            volume_endpoint='http://volumes.remote1')
        config.post_config()
        extend.load_extensions()
示例#11
0
    def setUp(self):
        super(TestCase, self).setUp()
        self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))

        fixtures.MockPatchObject(time, 'time', lambda: 1234)

        self.requests_mock = self.useFixture(fixture.Fixture())
示例#12
0
    def setUp(self):
        """Run before each test method to initialize test environment."""
        super(TestCase, self).setUp()
        self.log_fixture = self.useFixture(fixtures.FakeLogger())

        self.requests = self.useFixture(req_fixture.Fixture())
        self.client = self.get_client()
示例#13
0
    def setUp(self):
        """Run before each test."""
        super(ShellTest, self).setUp()
        for var in self.FAKE_ENV:
            self.useFixture(
                fixtures.EnvironmentVariable(var, self.FAKE_ENV[var]))

        self.shell = shell.OpenStackCinderShell()

        # HACK(bcwaldon): replace this when we start using stubs
        self.old_get_client_class = client.get_client_class
        client.get_client_class = lambda *_: fakes.FakeClient

        self.requests = self.useFixture(requests_mock_fixture.Fixture())
        self.requests.register_uri(
            'GET',
            keystone_client.BASE_URL,
            text=keystone_client.keystone_request_callback)
        token = keystone_client_fixture.V2Token()
        s = token.add_service('volume', 'cinder')
        s.add_endpoint(public='http://127.0.0.1:8776')

        self.requests.post(keystone_client.BASE_URL + 'v2.0/tokens',
                           json=token)
        self.requests.get('http://127.0.0.1:8776',
                          json=fixture_base.generate_version_output())
示例#14
0
    def use_keystone_v2(self):
        self.adapter = self.useFixture(rm_fixture.Fixture())
        self.calls = []
        self._uri_registry.clear()

        # occ > 1.26.0 fixes keystoneclient construction. Unfortunately, it
        # breaks our mocking of what keystoneclient does here. Since we're
        # close to just getting rid of ksc anyway, just put in a version match
        occ_version = du_version.StrictVersion(occ.__version__)
        if occ_version > du_version.StrictVersion('1.26.0'):
            endpoint_uri = 'https://identity.example.com/v2.0'
        else:
            endpoint_uri = 'https://identity.example.com/'

        self.__do_register_uris([
            dict(method='GET',
                 uri='https://identity.example.com/',
                 text=open(self.discovery_json, 'r').read()),
            dict(method='POST',
                 uri='https://identity.example.com/v2.0/tokens',
                 text=open(
                     os.path.join(self.fixtures_directory, 'catalog-v2.json'),
                     'r').read()),
            dict(method='GET',
                 uri=endpoint_uri,
                 text=open(self.discovery_json, 'r').read()),
            dict(method='GET',
                 uri='https://identity.example.com/',
                 text=open(self.discovery_json, 'r').read())
        ])

        self._make_test_cloud(cloud_name='_test_cloud_v2_',
                              identity_api_version='2.0')
示例#15
0
    def test_v2_download_has_no_stray_output_to_stdout(self):
        """Ensure no stray print statements corrupt the image"""
        saved_stdout = sys.stdout
        try:
            sys.stdout = output = testutils.FakeNoTTYStdout()
            id = image_show_fixture['id']
            headers = {
                'Content-Length': '4',
                'Content-type': 'application/octet-stream'
            }
            fake = testutils.FakeResponse(headers, six.StringIO('DATA'))

            self.requests = self.useFixture(rm_fixture.Fixture())
            self.requests.get('http://example.com/v2/images/%s/file' % id,
                              headers=headers,
                              raw=fake)

            shell = openstack_shell.OpenStackImagesShell()
            argstr = ('--os-image-api-version 2 --os-auth-token faketoken '
                      '--os-image-url http://example.com '
                      'image-download %s' % id)
            shell.main(argstr.split())
            # Ensure we have *only* image data
            self.assertEqual('DATA', output.getvalue())
        finally:
            sys.stdout = saved_stdout
示例#16
0
 def setUp(self):
     super(TestAuthManager, self).setUp()
     self.url = 'https://oauth2/tokens'
     self.user_name = 'test_user'
     self.password = '******'
     auth.auth_manager = auth._AuthManager()
     self.requests_mock = self.useFixture(requests_mock_fixture.Fixture())
 def setUp(self, *args, **kwargs):
     # logging.basicConfig(level=logging.DEBUG)
     super(TestAuthentication, self).setUp(*args, **kwargs)
     self.client = Client(username='******',
                          password='******',
                          ecs_endpoint='http://127.0.0.1:4443',
                          token_endpoint='http://127.0.0.1:4443/login')
     self.requests_mock = self.useFixture(fixture.Fixture())
示例#18
0
    def setUp(self):
        super(TestClient, self).setUp()
        self.mock = self.useFixture(fixture.Fixture())

        self.endpoint = 'http://example.com:9292'
        self.token = u'abc123'

        self.client = getattr(self, self.create_client)()
示例#19
0
    def setUp(self):
        super(S3TokenMiddlewareTestBase, self).setUp()

        self.conf = {
            'www_authenticate_uri': self.TEST_WWW_AUTHENTICATE_URI,
        }

        self.requests_mock = self.useFixture(rm_fixture.Fixture())
示例#20
0
    def setUp(self):
        super(S3TokenMiddlewareTestBase, self).setUp()

        self.conf = {
            'auth_uri': self.TEST_AUTH_URI,
        }

        self.requests_mock = self.useFixture(rm_fixture.Fixture())
示例#21
0
    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 = self.useFixture(fixture.Fixture())
示例#22
0
 def use_keystone_v3(self):
     self.adapter = self.useFixture(rm_fixture.Fixture())
     self.calls = []
     self._uri_registry.clear()
     self.__do_register_uris([
         self.get_keystone_discovery(),
         self.get_keystone_v3_token(),
     ])
     self._make_test_cloud(identity_api_version='3')
示例#23
0
    def setUp(self):
        super(HttpsCheckTestCase, self).setUp()
        opts._register(self.conf)
        self.requests_mock = self.useFixture(rm_fixture.Fixture())

        # ensure environment variables don't mess with our test results
        # https://requests.readthedocs.io/en/master/user/advanced/#ssl-cert-verification
        self.useFixture(fixtures.EnvironmentVariable('REQUESTS_CA_BUNDLE'))
        self.useFixture(fixtures.EnvironmentVariable('CURL_CA_BUNDLE'))
 def setUp(self):
     super(TestClient, self).setUp()
     self.responses = self.useFixture(fixture.Fixture())
     self.endpoint = 'http://localhost:9311'
     self.project_id = 'project_id'
     self.session = session.Session()
     self.httpclient = client._HTTPClient(session=self.session,
                                          endpoint=self.endpoint,
                                          project_id=self.project_id)
示例#25
0
    def setUp(self):
        super(BaseCinderTestCase, self).setUp()
        cinder.reset_globals()
        self.requests = self.useFixture(fixture.Fixture())
        self.api = cinder.API()

        self.context = context.RequestContext('username',
                                              'project_id',
                                              auth_token='token',
                                              service_catalog=self.CATALOG)
示例#26
0
    def setUp(self):
        super(BaseClientTest, self).setUp()

        self._client = client.Client(session=requests,
                                     username="******",
                                     password="******",
                                     kuberlab_url=self.TEST_URL)

        self.workspaces = self._client.workspaces
        self.requests_mock = self.useFixture(fixture.Fixture())
示例#27
0
    def setUp(self):
        super(S3TokenMiddlewareTestBase, self).setUp()

        self.conf = {
            'auth_host': self.TEST_HOST,
            'auth_port': self.TEST_PORT,
            'auth_protocol': self.TEST_PROTOCOL,
        }

        self.requests = self.useFixture(rm_fixture.Fixture())
示例#28
0
 def test_get(self):
     self.requests_mock = self.useFixture(fixture.Fixture())
     with open("tests/fixtures/characters.json", "r") as file:
         data = json.load(file)
     client = Marvel()
     self.requests_mock.register_uri(
         "GET",
         f"{client.URL}/v1/public/characters{client.query_string}",
         json=data)
     results = client.testing()
     assert results is not None
 def setUp(self, host='localhost', tunnel_ip='10.10.10.10', timeout=None):
     super(CiscoCsrBaseTestCase, self).setUp()
     self.base_url = BASE_URL % host
     self.requests = self.useFixture(mock_fixture.Fixture())
     info = {
         'rest_mgmt_ip': host,
         'username': '******',
         'password': '******',
         'timeout': timeout
     }
     self.csr = csr_client.CsrRestClient(info)
示例#30
0
    def setUp(self):
        super(TestObjectAll, self).setUp()

        self.app.client_manager.session = session.Session()
        self.requests_mock = self.useFixture(fixture.Fixture())

        # TODO(dtroyer): move this to object_fakes.TestObjectv1
        self.app.client_manager.object_store = object_store.APIv1(
            session=self.app.client_manager.session,
            endpoint=object_fakes.ENDPOINT,
        )