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())
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())
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)
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={})
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
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')
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())
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 = '******'
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()
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())
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()
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())
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')
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
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())
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)()
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())
def setUp(self):
super(S3TokenMiddlewareTestBase, self).setUp()
self.conf = {
'auth_uri': self.TEST_AUTH_URI,
}
self.requests_mock = self.useFixture(rm_fixture.Fixture())
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())
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')
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)
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)
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())
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())
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)
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,
)
