def setUp(self):
super(DiskAdapter, self).setUp()
self.std_disk_adpt_fx = self.useFixture(
fixtures.MockPatch('nova_powervm.virt.powervm.disk.localdisk.'
'LocalStorage'))
self.std_disk_adpt = self.std_disk_adpt_fx.mock
def setUp(self):
super(TestAccountGeneratorV2, self).setUp()
self.mock_config_and_opts(self.identity_version)
self.useFixture(fixtures.MockPatch(
'tempest.lib.auth.AuthProvider.set_auth',
return_value=self.identity_response))
def _setUp(self):
self.useFixture(
fixtures.MockPatch(
"snapcraft.plugins.get_plugin_for_base", side_effect=self.get_plugin
)
)
def setUp(self):
super().setUp()
self.useFixture(fixtures.MockPatch("os.path.exists",
return_value=True))
def mockpatch(self, methstr):
return self.useFixture(fixtures.MockPatch(methstr)).mock
def setUp(self):
p = 'keystonemiddleware.audit._notifier.oslo_messaging'
f = fixtures.MockPatch(p, None)
self.messaging_fixture = self.useFixture(f)
super(TestLoggingNotifier, self).setUp()
def setUp(self):
super(TestServiceClients, self).setUp()
self.useFixture(
fixtures.MockPatch('tempest.lib.services.clients.tempest_modules',
return_value=set(['fake_service1'])))
def setUp(self):
super(OpenStackScenarioTestCase, self).setUp()
self.osclients = fixtures.MockPatch("rally.osclients.Clients")
self.useFixture(self.osclients)
self.context = test.get_test_context()
self.context.update({"foo": "bar"})
def setUp(self):
super(_LibvirtEvacuateTest, self).setUp()
self.useFixture(nova_fixtures.CinderFixture(self))
self.useFixture(nova_fixtures.NeutronFixture(self))
self.useFixture(nova_fixtures.GlanceFixture(self))
self.useFixture(func_fixtures.PlacementFixture())
fake_network.set_stub_network_methods(self)
api_fixture = self.useFixture(
nova_fixtures.OSAPIFixture(api_version='v2.1'))
self.api = api_fixture.admin_api
# force_down and evacuate without onSharedStorage
self.api.microversion = '2.14'
fake_notifier.stub_notifier(self)
self.addCleanup(fake_notifier.reset)
self.useFixture(fakelibvirt.FakeLibvirtFixture())
# Fake out all the details of volume connection
self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver.get_volume_connector'))
self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._connect_volume'))
# For cleanup
self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._disconnect_volume'))
volume_config = libvirt_config.LibvirtConfigGuestDisk()
volume_config.driver_name = 'fake-volume-driver'
volume_config.source_path = 'fake-source-path'
volume_config.target_dev = 'fake-target-dev'
volume_config.target_bus = 'fake-target-bus'
get_volume_config = self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._get_volume_config')
).mock
get_volume_config.return_value = volume_config
# Ensure our computes report lots of available disk, vcpu, and ram
lots = 10000000
get_local_gb_info = self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._get_local_gb_info')
).mock
get_local_gb_info.return_value = {
'total': lots,
'free': lots,
'used': 1
}
get_vcpu_available = self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._get_vcpu_available')
).mock
get_vcpu_available.return_value = set(cpu for cpu in range(24))
get_memory_mb_total = self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.host.Host.get_memory_mb_total')).mock
get_memory_mb_total.return_value = lots
# Mock out adding rng devices
self.useFixture(
fixtures.MockPatch(
'nova.virt.libvirt.driver.LibvirtDriver._add_rng_device')).mock
self.start_service('conductor')
self.start_service('scheduler')
self.flags(compute_driver='libvirt.LibvirtDriver')
ctxt = context.get_admin_context()
for flavor in FLAVOR_FIXTURES:
objects.Flavor(context=ctxt, **flavor).create()
def setUp(self):
self.client = self.useFixture(
fixtures.MockPatch(
'aodh.evaluator.gnocchi.client')).mock.Client.return_value
self.prepared_alarms = [
models.Alarm(name='instance_running_hot',
description='instance_running_hot',
type='gnocchi_resources_threshold',
enabled=True,
user_id='foobar',
project_id='snafu',
alarm_id=uuidutils.generate_uuid(),
state='insufficient data',
state_reason='insufficient data',
state_timestamp=constants.MIN_DATETIME,
timestamp=constants.MIN_DATETIME,
insufficient_data_actions=[],
ok_actions=[],
alarm_actions=[],
repeat_actions=False,
time_constraints=[],
severity='low',
rule=dict(comparison_operator='gt',
threshold=80.0,
evaluation_periods=5,
aggregation_method='mean',
granularity=60,
metric='cpu_util',
resource_type='instance',
resource_id='my_instance')),
models.Alarm(
name='group_running_idle',
description='group_running_idle',
type='gnocchi_aggregation_by_metrics_threshold',
enabled=True,
user_id='foobar',
project_id='snafu',
state='insufficient data',
state_reason='insufficient data',
state_timestamp=constants.MIN_DATETIME,
timestamp=constants.MIN_DATETIME,
insufficient_data_actions=[],
ok_actions=[],
alarm_actions=[],
repeat_actions=False,
alarm_id=uuidutils.generate_uuid(),
time_constraints=[],
rule=dict(comparison_operator='le',
threshold=10.0,
evaluation_periods=4,
aggregation_method='max',
granularity=300,
metrics=[
'0bb1604d-1193-4c0a-b4b8-74b170e35e83',
'9ddc209f-42f8-41e1-b8f1-8804f59c4053'
]),
),
models.Alarm(name='instance_not_running',
description='instance_running_hot',
type='gnocchi_aggregation_by_resources_threshold',
enabled=True,
user_id='foobar',
project_id='snafu',
alarm_id=uuidutils.generate_uuid(),
state='insufficient data',
state_reason='insufficient data',
state_timestamp=constants.MIN_DATETIME,
timestamp=constants.MIN_DATETIME,
insufficient_data_actions=[],
ok_actions=[],
alarm_actions=[],
repeat_actions=False,
time_constraints=[],
rule=dict(comparison_operator='gt',
threshold=80.0,
evaluation_periods=6,
aggregation_method='mean',
granularity=50,
metric='cpu_util',
resource_type='instance',
query='{"=": {"server_group": '
'"my_autoscaling_group"}}')),
]
super(TestGnocchiEvaluatorBase, self).setUp()
def setUp(self):
super().setUp()
# Our experimental environment variable is sticky
self.useFixture(
fixtures.EnvironmentVariable(
"SNAPCRAFT_EXPERIMENTAL_PROGRESSIVE_RELEASES", None
)
)
self.fake_store_login = fixtures.MockPatchObject(storeapi.StoreClient, "login")
self.useFixture(self.fake_store_login)
self.fake_store_register = fixtures.MockPatchObject(
storeapi._dashboard_api.DashboardAPI, "register"
)
self.useFixture(self.fake_store_register)
self.fake_store_account_info = fixtures.MockPatchObject(
storeapi._dashboard_api.DashboardAPI,
"get_account_information",
return_value={
"account_id": "abcd",
"account_keys": list(),
"snaps": {
"16": {
"snap-test": {
"snap-id": "snap-test-snap-id",
"status": "Approved",
"private": False,
"since": "2016-12-12T01:01Z",
"price": "0",
},
"basic": {
"snap-id": "basic-snap-id",
"status": "Approved",
"private": False,
"since": "2016-12-12T01:01Z",
"price": "0",
},
}
},
},
)
self.useFixture(self.fake_store_account_info)
self.fake_store_status = fixtures.MockPatchObject(
storeapi._dashboard_api.DashboardAPI, "snap_status", return_value=dict()
)
self.useFixture(self.fake_store_status)
self.fake_store_release = fixtures.MockPatchObject(
storeapi.StoreClient, "release"
)
self.useFixture(self.fake_store_release)
self.fake_store_register_key = fixtures.MockPatchObject(
storeapi._dashboard_api.DashboardAPI, "register_key"
)
self.useFixture(self.fake_store_register_key)
# channel-map endpoint
self.channel_map = ChannelMap.unmarshal(
{
"channel-map": [
{
"architecture": "amd64",
"channel": "2.1/beta",
"expiration-date": None,
"revision": 19,
"progressive": {
"paused": None,
"percentage": None,
"current-percentage": None,
},
},
{
"architecture": "amd64",
"channel": "2.0/beta",
"expiration-date": None,
"revision": 18,
"progressive": {
"paused": None,
"percentage": None,
"current-percentage": None,
},
},
],
"revisions": [
{"architectures": ["amd64"], "revision": 19, "version": "10"},
{"architectures": ["amd64"], "revision": 18, "version": "10"},
],
"snap": {
"name": "snap-test",
"channels": [
{
"branch": None,
"fallback": None,
"name": "2.1/stable",
"risk": "stable",
"track": "2.1",
},
{
"branch": None,
"fallback": "2.1/stable",
"name": "2.1/candidate",
"risk": "candidate",
"track": "2.1",
},
{
"branch": None,
"fallback": "2.1/candidate",
"name": "2.1/beta",
"risk": "beta",
"track": "2.1",
},
{
"branch": None,
"fallback": "2.1/beta",
"name": "2.1/edge",
"risk": "edge",
"track": "2.1",
},
{
"branch": None,
"fallback": None,
"name": "2.0/stable",
"risk": "stable",
"track": "2.0",
},
{
"branch": None,
"fallback": "2.0/stable",
"name": "2.0/candidate",
"risk": "candidate",
"track": "2.0",
},
{
"branch": None,
"fallback": "2.0/candidate",
"name": "2.0/beta",
"risk": "beta",
"track": "2.0",
},
{
"branch": None,
"fallback": "2.0/beta",
"name": "2.0/edge",
"risk": "edge",
"track": "2.0",
},
],
"default-track": "2.1",
"tracks": [
{
"name": "2.0",
"status": "default",
"creation-date": "2019-10-17T14:11:59Z",
"version-pattern": "2\\.*",
},
{
"name": "latest",
"status": "active",
"creation-date": None,
"version-pattern": None,
},
],
},
}
)
self.fake_store_get_snap_channel_map = fixtures.MockPatchObject(
storeapi.StoreClient, "get_snap_channel_map", return_value=self.channel_map
)
self.useFixture(self.fake_store_get_snap_channel_map)
self.releases = Releases.unmarshal(
{
"revisions": [
{
"architectures": ["i386"],
"base": "core20",
"build_url": None,
"confinement": "strict",
"created_at": " 2016-09-27T19:23:40Z",
"grade": "stable",
"revision": 2,
"sha3-384": "a9060ef4872ccacbfa440617a76fcd84967896b28d0d1eb7571f00a1098d766e7e93353b084ba6ad841d7b14b95ede48",
"size": 20,
"status": "Published",
"version": "2.0.1",
},
{
"architectures": ["amd64"],
"base": "core20",
"build_url": None,
"confinement": "strict",
"created_at": "2016-09-27T18:38:43Z",
"grade": "stable",
"revision": 1,
"sha3-384": "a9060ef4872ccacbfa440617a76fcd84967896b28d0d1eb7571f00a1098d766e7e93353b084ba6ad841d7b14b95ede48",
"size": 20,
"status": "Published",
"version": "2.0.2",
},
],
"releases": [
{
"architecture": "amd64",
"branch": None,
"channel": "latest/stable",
"expiration-date": None,
"revision": 1,
"risk": "stable",
"track": "latest",
"when": "2020-02-12T17:51:40.891996Z",
},
{
"architecture": "i386",
"branch": None,
"channel": "latest/stable",
"expiration-date": None,
"revision": None,
"risk": "stable",
"track": "latest",
"when": "2020-02-11T17:51:40.891996Z",
},
{
"architecture": "amd64",
"branch": None,
"channel": "latest/edge",
"expiration-date": None,
"revision": 1,
"risk": "stable",
"track": "latest",
"when": "2020-01-12T17:51:40.891996Z",
},
],
}
)
self.fake_store_get_releases = fixtures.MockPatchObject(
storeapi.StoreClient, "get_snap_releases", return_value=self.releases
)
self.useFixture(self.fake_store_get_releases)
# Uploading
self.mock_tracker = mock.Mock(storeapi._status_tracker.StatusTracker)
self.mock_tracker.track.return_value = {
"code": "ready_to_release",
"processed": True,
"can_release": True,
"url": "/fake/url",
"revision": 19,
}
self.fake_store_upload_precheck = fixtures.MockPatchObject(
storeapi.StoreClient, "upload_precheck"
)
self.useFixture(self.fake_store_upload_precheck)
self.fake_store_upload = fixtures.MockPatchObject(
storeapi.StoreClient, "upload", return_value=self.mock_tracker
)
self.useFixture(self.fake_store_upload)
# Mock the snap command, pass through a select few.
self.fake_check_output = fixtures.MockPatch(
"subprocess.check_output", side_effect=mock_check_output
)
self.useFixture(self.fake_check_output)
# Pretend that the snap command is available
self.fake_package_installed = fixtures.MockPatch(
"snapcraft.internal.repo.Repo.is_package_installed", return_value=True
)
self.useFixture(self.fake_package_installed)
def setUp(self):
super(ServerGroupPolicyTest, self).setUp()
self.controller = server_groups.ServerGroupController()
self.req = fakes.HTTPRequest.blank('')
self.mock_get = self.useFixture(
fixtures.MockPatch('nova.objects.InstanceGroup.get_by_uuid')).mock
self.sg = [
objects.InstanceGroup(uuid=uuids.fake_id,
name='fake',
project_id=self.project_id,
user_id='u1',
policies=[],
members=[]),
objects.InstanceGroup(uuid=uuids.fake_id,
name='fake2',
project_id='proj2',
user_id='u2',
policies=[],
members=[])
]
self.mock_get.return_value = self.sg[0]
# Check that admin or and owner is able to delete
# the server group.
self.admin_or_owner_authorized_contexts = [
self.legacy_admin_context, self.system_admin_context,
self.project_admin_context, self.project_member_context,
self.project_reader_context, self.project_foo_context
]
# Check that non-admin/owner is not able to delete
# the server group.
self.admin_or_owner_unauthorized_contexts = [
self.system_member_context,
self.system_reader_context,
self.system_foo_context,
self.other_project_member_context,
self.other_project_reader_context,
]
# Check that system reader or owner is able to get
# the server group. Due to old default everyone
# is allowed to perform this operation.
self.system_reader_or_owner_authorized_contexts = [
self.legacy_admin_context, self.system_admin_context,
self.project_admin_context, self.project_member_context,
self.project_reader_context, self.system_member_context,
self.system_reader_context, self.project_foo_context
]
self.system_reader_or_owner_unauthorized_contexts = [
self.system_foo_context,
self.other_project_member_context,
self.other_project_reader_context,
]
# Check that everyone is able to list
# theie own server group. Due to old defaults everyone
# is able to list their server groups.
self.everyone_authorized_contexts = [
self.legacy_admin_context,
self.system_admin_context,
self.project_admin_context,
self.project_member_context,
self.project_reader_context,
self.project_foo_context,
self.system_member_context,
self.system_reader_context,
self.system_foo_context,
self.other_project_member_context,
self.other_project_reader_context,
]
self.everyone_unauthorized_contexts = []
# Check that project member is able to create server group.
# Due to old defaults everyone is able to list their server groups.
self.project_member_authorized_contexts = [
self.legacy_admin_context,
self.system_admin_context,
self.project_admin_context,
self.project_member_context,
self.system_member_context,
self.project_reader_context,
self.project_foo_context,
self.system_reader_context,
self.system_foo_context,
self.other_project_member_context,
self.other_project_reader_context,
]
self.project_member_unauthorized_contexts = []
def setUp(self):
super(FlavorExtraSpecsPolicyTest, self).setUp()
self.controller = flavors_extraspecs.FlavorExtraSpecsController()
self.flavor_ctrl = flavors.FlavorsController()
self.fm_ctrl = flavor_manage.FlavorManageController()
self.server_ctrl = servers.ServersController()
self.req = fakes.HTTPRequest.blank('')
self.server_ctrl._view_builder._add_security_grps = mock.MagicMock()
self.server_ctrl._view_builder._get_metadata = mock.MagicMock()
self.server_ctrl._view_builder._get_addresses = mock.MagicMock()
self.server_ctrl._view_builder._get_host_id = mock.MagicMock()
self.server_ctrl._view_builder._get_fault = mock.MagicMock()
self.server_ctrl._view_builder._add_host_status = mock.MagicMock()
self.instance = fake_instance.fake_instance_obj(
self.project_member_context,
id=1,
uuid=uuids.fake_id,
project_id=self.project_id,
vm_state=vm_states.ACTIVE)
self.mock_get = self.useFixture(
fixtures.MockPatch('nova.api.openstack.common.get_instance')).mock
self.mock_get.return_value = self.instance
fakes.stub_out_secgroup_api(self,
security_groups=[{
'name': 'default'
}])
self.mock_get_all = self.useFixture(
fixtures.MockPatchObject(self.server_ctrl.compute_api,
'get_all')).mock
self.mock_get_all.return_value = objects.InstanceList(
objects=[self.instance])
def get_flavor_extra_specs(context, flavor_id):
return fake_flavor.fake_flavor_obj(
self.project_member_context,
id=1,
uuid=uuids.fake_id,
project_id=self.project_id,
is_public=False,
extra_specs={'hw:cpu_policy': 'shared'},
expected_attrs='extra_specs')
self.stub_out('nova.api.openstack.common.get_flavor',
get_flavor_extra_specs)
# Check that all are able to get flavor extra specs.
self.all_authorized_contexts = [
self.legacy_admin_context, self.system_admin_context,
self.project_admin_context, self.project_member_context,
self.project_reader_context, self.project_foo_context,
self.system_member_context, self.system_reader_context,
self.system_foo_context, self.other_project_member_context,
self.other_project_reader_context
]
self.all_unauthorized_contexts = []
# Check that all system scoped are able to get flavor extra specs.
self.all_system_authorized_contexts = [
self.legacy_admin_context, self.system_admin_context,
self.project_admin_context, self.project_member_context,
self.project_reader_context, self.project_foo_context,
self.system_member_context, self.system_reader_context,
self.system_foo_context, self.other_project_member_context,
self.other_project_reader_context
]
self.all_system_unauthorized_contexts = []
# Check that admin is able to create, update and delete flavor
# extra specs.
self.admin_authorized_contexts = [
self.legacy_admin_context, self.system_admin_context,
self.project_admin_context
]
# Check that non-admin is not able to create, update and
# delete flavor extra specs.
self.admin_unauthorized_contexts = [
self.system_member_context, self.system_reader_context,
self.system_foo_context, self.project_member_context,
self.project_reader_context, self.project_foo_context,
self.other_project_member_context,
self.other_project_reader_context
]
def setUp(self):
super(HostCPUStats, self).setUp()
self.host_cpu_stats = self.useFixture(
fixtures.MockPatch('nova_powervm.virt.powervm.host.HostCPUStats'))
def test_is_resource_deleted_false(self):
mod = ('tempest.lib.services.compute.security_groups_client.'
'SecurityGroupsClient.show_security_group')
self.useFixture(fixtures.MockPatch(mod, return_value='success'))
self.assertFalse(self.client.is_resource_deleted('fake-id'))
def test_evacuate_failure_nonshared_instancedir(self):
"""Assert the failure cleanup behaviour of non-shared instance storage
If we fail during evacuate and the instance directory didn't
previously exist on the destination, we should delete it
"""
# Create instances on compute0
compute0 = self._start_compute('compute0')
servers = self._create_servers()
compute1 = self._swap_computes(compute0)
# Create a 'pass-through' mock for ensure_tree so we can log its calls
orig_ensure_tree = fileutils.ensure_tree
mock_ensure_tree = self.useFixture(
fixtures.MockPatch('oslo_utils.fileutils.ensure_tree',
side_effect=orig_ensure_tree)).mock
for server in servers:
name = server['name']
source_instance_path = self.source_instance_path(server)
dest_instance_path = self.dest_instance_path(server)
# Check that we've got an instance directory on the source and not
# on the dest
self.assertTrue(
os.path.exists(source_instance_path),
"Source instance directory %s for server %s does "
"not exist" % (source_instance_path, name))
self.assertFalse(
os.path.exists(dest_instance_path),
"Destination instance directory %s for server %s "
"exists" % (dest_instance_path, name))
# By default our 2 compute hosts share the same instance directory
# on the test runner. Force a different directory while running
# evacuate on compute1 so we don't have shared storage.
def dest_get_instance_path(instance, relative=False):
if relative:
return instance.uuid
return dest_instance_path
with mock.patch('nova.virt.libvirt.utils.get_instance_path') \
as get_instance_path:
get_instance_path.side_effect = dest_get_instance_path
server = self._evacuate_with_failure(server, compute1)
# Check that we've got an instance directory on the source and not
# on the dest, but that the dest was created
self.assertTrue(
os.path.exists(source_instance_path),
"Source instance directory %s for server %s does "
"not exist" % (source_instance_path, name))
self.assertFalse(
os.path.exists(dest_instance_path),
"Destination instance directory %s for server %s "
"exists" % (dest_instance_path, name))
mock_ensure_tree.assert_called_with(dest_instance_path)
self.assert_disks_nonshared_instancedir(server)
# Check we're still on the failed source host
self.assertEqual('compute0', server['OS-EXT-SRV-ATTR:host'])
def setUp(self):
super().setUp()
self.fake_check_call = fixtures.MockPatch("subprocess.check_call")
self.useFixture(self.fake_check_call)
def _setUp(self):
super(PlanManagementFixture, self)._setUp()
self.mock_tarball = self.useFixture(
fixtures.MockPatch(
'tripleoclient.workflows.plan_management.tarball')).mock
def _test_failover_scenario(self, enable_cancel_on_failover=False):
# NOTE(sileht): run this test only if functional suite run of a driver
# that use rabbitmq as backend
self.driver = os.environ.get('TRANSPORT_DRIVER')
if self.driver not in self.DRIVERS:
self.skipTest("TRANSPORT_DRIVER is not set to a rabbit driver")
# NOTE(sileht): Allow only one response at a time, to
# have only one tcp connection for reply and ensure it will failover
# correctly
self.config(heartbeat_timeout_threshold=1,
rpc_conn_pool_size=1,
kombu_reconnect_delay=0,
rabbit_retry_interval=0,
rabbit_retry_backoff=0,
enable_cancel_on_failover=enable_cancel_on_failover,
group='oslo_messaging_rabbit')
self.pifpaf = self.useFixture(
rabbitmq.RabbitMQDriver(cluster=True, port=5692))
self.url = self.pifpaf.env["PIFPAF_URL"]
self.n1 = self.pifpaf.env["PIFPAF_RABBITMQ_NODENAME1"]
self.n2 = self.pifpaf.env["PIFPAF_RABBITMQ_NODENAME2"]
self.n3 = self.pifpaf.env["PIFPAF_RABBITMQ_NODENAME3"]
# ensure connections will be establish to the first node
self.pifpaf.stop_node(self.n2)
self.pifpaf.stop_node(self.n3)
self.servers = self.useFixture(
utils.RpcServerGroupFixture(self.conf,
self.url,
endpoint=self,
names=["server"]))
# Don't randomize rabbit hosts
self.useFixture(
fixtures.MockPatch('oslo_messaging._drivers.impl_rabbit.random',
side_effect=lambda x: x))
# NOTE(sileht): this connects server connections and reply
# connection to nodename n1
self.client = self.servers.client(0)
self.client.ping()
self._check_ports(self.pifpaf.port)
# Switch to node n2
self.pifpaf.start_node(self.n2)
self.assertEqual("callback done", self.client.kill_and_process())
self.assertEqual("callback done", self.client.just_process())
self._check_ports(self.pifpaf.get_port(self.n2))
# Switch to node n3
self.pifpaf.start_node(self.n3)
time.sleep(0.1)
self.pifpaf.kill_node(self.n2, signal=signal.SIGKILL)
time.sleep(0.1)
self.assertEqual("callback done", self.client.just_process())
self._check_ports(self.pifpaf.get_port(self.n3))
self.pifpaf.start_node(self.n1)
time.sleep(0.1)
self.pifpaf.kill_node(self.n3, signal=signal.SIGKILL)
time.sleep(0.1)
self.assertEqual("callback done", self.client.just_process())
self._check_ports(self.pifpaf.get_port(self.n1))
def setUp(self):
super(ForeverRetryUncaughtExceptionsTest, self).setUp()
self._exceptions = []
self.useFixture(fixtures.MockPatch('time.sleep', return_value=None))
def setUp(self):
super(TestRetryHandler, self).setUp()
self.now = time.time()
f_time = self.useFixture(fixtures.MockPatch('time.time'))
f_time.mock.return_value = self.now
def test_setup_environment_content_arm64(self):
self.useFixture(
fixtures.MockPatch("platform.machine", return_value="aarch64"))
recorded_files = dict()
@contextlib.contextmanager
def fake_namedtempfile(*, suffix: str, **kwargs):
# Usage hides the file basename in the suffix.
tmp_path = os.path.join(self.path, "tmpfile")
with open(tmp_path, "wb") as f_write:
yield f_write
with open(tmp_path, "r") as f_read:
recorded_files[suffix] = f_read.read()
self.useFixture(
fixtures.MockPatch("tempfile.NamedTemporaryFile",
new=fake_namedtempfile))
provider = ProviderImpl(project=self.project, echoer=self.echoer_mock)
provider._setup_environment()
self.expectThat(
recorded_files,
Equals({
".bashrc":
'#!/bin/bash\nexport PS1="\\h \\$(/bin/_snapcraft_prompt)# "\n',
"00-snapcraft":
'Apt::Install-Recommends "false";\n',
"_snapcraft_prompt":
dedent("""\
#!/bin/bash
if [[ "$PWD" =~ ^$HOME.* ]]; then
path="${PWD/#$HOME/\\ ..}"
if [[ "$path" == " .." ]]; then
ps1=""
else
ps1="$path"
fi
else
ps1="$PWD"
fi
echo -n $ps1
"""),
"default.sources":
dedent("""\
Types: deb deb-src
URIs: http://ports.ubuntu.com/ubuntu-ports
Suites: xenial xenial-updates
Components: main multiverse restricted universe
"""),
"default-security.sources":
dedent("""\
Types: deb deb-src
URIs: http://ports.ubuntu.com/ubuntu-ports
Suites: xenial-security
Components: main multiverse restricted universe
"""),
"sources.list":
"",
}),
)
def patch(self, target, **kwargs):
mockfixture = self.useFixture(fixtures.MockPatch(target, **kwargs))
return mockfixture.mock
def setUp(self):
super().setUp()
self.fake_run = fixtures.MockPatch("snapcraft.internal.common.run")
self.useFixture(self.fake_run)
def start_fixture(self):
"""Create necessary temp files and do the config dance."""
global LOAD_APP_KWARGS
if not os.getenv("GNOCCHI_TEST_DEBUG"):
self.output = base.CaptureOutput()
self.output.setUp()
data_tmp_dir = tempfile.mkdtemp(prefix='gnocchi')
if os.getenv("GABBI_LIVE"):
dcf = None
else:
dcf = []
conf = service.prepare_service([],
conf=utils.prepare_conf(),
default_config_files=dcf,
logging_level=logging.DEBUG,
skip_log_opts=True)
py_root = os.path.abspath(
os.path.join(
os.path.dirname(__file__),
'..',
'..',
))
conf.set_override('paste_config',
os.path.join(py_root, 'rest', 'api-paste.ini'),
group="api")
conf.set_override('policy_file',
os.path.join(py_root, 'rest', 'policy.yaml'),
group="oslo_policy")
# NOTE(sileht): This is not concurrency safe, but only this tests file
# deal with cors, so we are fine. set_override don't work because cors
# group doesn't yet exists, and we the CORS middleware is created it
# register the option and directly copy value of all configurations
# options making impossible to override them properly...
cfg.set_defaults(cors.CORS_OPTS, allowed_origin="http://foobar.com")
self.conf = conf
self.tmp_dir = data_tmp_dir
if conf.indexer.url is None:
raise case.SkipTest("No indexer configured")
storage_driver = os.getenv("GNOCCHI_TEST_STORAGE_DRIVER", "file")
conf.set_override('driver', storage_driver, 'storage')
if conf.storage.driver == 'file':
conf.set_override('file_basepath', data_tmp_dir, 'storage')
elif conf.storage.driver == 'ceph':
conf.set_override('ceph_conffile', os.getenv("CEPH_CONF"),
'storage')
self.ceph_pool_name = uuid.uuid4().hex
with open(os.devnull, 'w') as f:
subprocess.call(("ceph -c %s osd pool create %s "
"16 16 replicated") %
(os.getenv("CEPH_CONF"), self.ceph_pool_name),
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
subprocess.call(("ceph -c %s osd pool application "
"enable %s rbd") %
(os.getenv("CEPH_CONF"), self.ceph_pool_name),
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
conf.set_override('ceph_pool', self.ceph_pool_name, 'storage')
elif conf.storage.driver == "s3":
conf.set_override('s3_endpoint_url',
os.getenv("GNOCCHI_STORAGE_HTTP_URL"),
group="storage")
conf.set_override('s3_access_key_id', "gnocchi", group="storage")
conf.set_override('s3_secret_access_key',
"anythingworks",
group="storage")
conf.set_override("s3_bucket_prefix",
str(uuid.uuid4())[:26], "storage")
elif conf.storage.driver == "swift":
# NOTE(sileht): This fixture must start before any driver stuff
swift_fixture = fixtures.MockPatch('swiftclient.client.Connection',
base.FakeSwiftClient)
swift_fixture.setUp()
# NOTE(jd) All of that is still very SQL centric but we only support
# SQL for now so let's say it's good enough.
conf.set_override(
'url',
sqlalchemy.SQLAlchemyIndexer._create_new_database(
conf.indexer.url), 'indexer')
index = indexer.get_driver(conf)
index.upgrade()
# Set pagination to a testable value
conf.set_override('max_limit', 7, 'api')
conf.set_override('enable_proxy_headers_parsing', True, group="api")
self.index = index
self.coord = metricd.get_coordinator_and_start(str(uuid.uuid4()),
conf.coordination_url)
s = storage.get_driver(conf)
i = incoming.get_driver(conf)
if conf.storage.driver == 'redis':
# Create one prefix per test
s.STORAGE_PREFIX = str(uuid.uuid4()).encode()
if conf.incoming.driver == 'redis':
i.SACK_NAME_FORMAT = (str(uuid.uuid4()) +
incoming.IncomingDriver.SACK_NAME_FORMAT)
self.fixtures = [
fixtures.MockPatch("gnocchi.storage.get_driver", return_value=s),
fixtures.MockPatch("gnocchi.incoming.get_driver", return_value=i),
fixtures.MockPatch("gnocchi.indexer.get_driver",
return_value=self.index),
fixtures.MockPatch("gnocchi.cli.metricd.get_coordinator_and_start",
return_value=self.coord),
]
for f in self.fixtures:
f.setUp()
if conf.storage.driver == 'swift':
self.fixtures.append(swift_fixture)
LOAD_APP_KWARGS = {
'conf': conf,
}
s.upgrade()
i.upgrade(128)
# start up a thread to async process measures
self.metricd_thread = MetricdThread(chef.Chef(self.coord, i, index, s))
self.metricd_thread.start()
def setUp(self):
super(TestImportNodeMultiArch, self).setUp()
self.nodes_list = [{
"pm_user": "******",
"pm_addr": "192.168.122.1",
"pm_password": "******",
"pm_type": "pxe_ssh",
"mac": ["00:0b:d0:69:7e:59"],
}, {
"pm_user": "******",
"pm_addr": "192.168.122.2",
"pm_password": "******",
"pm_type": "pxe_ssh",
"arch": "x86_64",
"mac": ["00:0b:d0:69:7e:58"]
}, {
"pm_user": "******",
"pm_addr": "192.168.122.3",
"pm_password": "******",
"pm_type": "pxe_ssh",
"arch": "x86_64",
"platform": "SNB",
"mac": ["00:0b:d0:69:7e:58"]
}]
self.json_file = tempfile.NamedTemporaryFile(mode='w',
delete=False,
suffix='.json')
json.dump(self.nodes_list, self.json_file)
self.json_file.close()
self.addCleanup(os.unlink, self.json_file.name)
self.workflow = self.app.client_manager.workflow_engine
execution = mock.Mock()
execution.id = "IDID"
self.workflow.executions.create.return_value = execution
client = self.app.client_manager.tripleoclient
self.websocket = client.messaging_websocket()
# Get the command object to test
self.cmd = overcloud_node.ImportNode(self.app, None)
image = collections.namedtuple('image', ['id', 'name'])
self.app.client_manager.image = mock.Mock()
self.app.client_manager.image.images.list.return_value = [
image(id=3, name='overcloud-full'),
image(id=6, name='x86_64-overcloud-full'),
image(id=9, name='SNB-x86_64-overcloud-full'),
]
self.http_boot = '/var/lib/ironic/httpboot'
existing = ['agent', 'x86_64/agent', 'SNB-x86_64/agent']
existing = {
os.path.join(self.http_boot, name + ext)
for name in existing for ext in ('.kernel', '.ramdisk')
}
self.useFixture(
fixtures.MockPatch('os.path.exists',
autospec=True,
side_effect=lambda path: path in existing))
def setUp(self):
super(TestMemcachePoolAbstraction, self).setUp()
self.useFixture(
fixtures.MockPatch('oslo_cache._memcache_pool._MemcacheClient'))
def test_is_resource_deleted_true(self):
mod = ('tempest.lib.services.compute.security_groups_client.'
'SecurityGroupsClient.show_security_group')
self.useFixture(fixtures.MockPatch(mod, side_effect=lib_exc.NotFound))
self.assertTrue(self.client.is_resource_deleted('fake-id'))
def setUp(self):
self.client = self.useFixture(
fixtures.MockPatch(
'aodh.evaluator.gnocchi.client')).mock.Client.return_value
super(BaseCompositeEvaluate, self).setUp()
def setUp(self):
super(ImageAPI, self).setUp()
self.img_api_fx = self.useFixture(fixtures.MockPatch('nova.image.API'))
