def test_leaks_CIMInstance_property():
"""
Test function with a CIMInstance object that has one property.
"""
_ = CIMInstance('CIM_Foo', properties=[
CIMProperty('P1', value='p'),
])
def create_cimnamespace_instance(conn, namespace, interop_namespace,
klass):
"""
Build and execute CreateInstance for an instance of CIM_Namespace using
the `namespace` parameter as the value of the name property in the
instance. The instance is created in the `interop_namespace`
Parameters:
namespace (:term:`string`):
Namespace that this instance defines.
interop_namespace (:term:`string`):
Interop namespace for this environment.
klass (:class:`~pywbem.CIMClass`):
The CIM class CIM_Namespace which is used to create the instance.
Raises:
:exc:`~pywbem.CIMError`: For errors encountered with CreateInstance
"""
properties = NocaseDict([
('Name', namespace), ('CreationClassName', klass.classname),
('ObjectManagerName', OBJECTMANAGERNAME),
('ObjectManagerCreationClassName', OBJECTMANAGERCREATIONCLASSNAME),
('SystemName', SYSTEMNAME),
('SystemCreationClassName', SYSTEMCREATIONCLASSNAME)
])
new_instance = CIMInstance.from_class(klass,
property_values=properties)
conn.CreateInstance(new_instance, interop_namespace)
def test_leaks_CIMInstance_qualifier():
"""
Test function with a CIMInstance object that has one qualifier.
"""
_ = CIMInstance('CIM_Foo', qualifiers=[
CIMQualifier('Q1', value='q'),
])
def inst_from_classname(self,
class_name,
namespace=None,
property_list=None,
property_values=None,
include_missing_properties=True,
include_path=True):
# pylint: disable=too-many-arguments
"""
Build instance from classname using class_name property to get class
from a repository.
"""
cls = self.conn.GetClass(class_name,
namespace=namespace,
LocalOnly=False,
IncludeQualifiers=True,
IncludeClassOrigin=True,
PropertyList=property_list)
return CIMInstance.from_class(
cls,
namespace=namespace,
property_values=property_values,
include_missing_properties=include_missing_properties,
include_path=include_path)
def inst_from_classname(conn,
class_name,
namespace=None,
property_list=None,
property_values=None,
include_missing_properties=True,
include_path=True):
# TODO AM 8/18 The inst_from_classname() method is not used.
"""
Build instance from class using class_name property to get class
from a repository.
"""
cls = conn.GetClass(class_name,
namespace=namespace,
LocalOnly=False,
IncludeQualifiers=True,
include_class_origin=True,
property_list=property_list)
return CIMInstance.from_class(
cls,
namespace=namespace,
property_values=property_values,
include_missing_properties=include_missing_properties,
include_path=include_path)
def create_ciminstance(self):
"""
Create a sample instance with multiple properties and
property types.
"""
class TZ(tzinfo):
"""'Simplistic tsinfo subclass for this test"""
def utcoffset(self, dt): # pylint: disable=unused-argument
return timedelta(minutes=-399)
dt = datetime(year=2016,
month=3,
day=31,
hour=19,
minute=30,
second=40,
microsecond=654321,
tzinfo=MinutesFromUTC(120))
cim_dt = CIMDateTime(dt)
props_input = {
'S1':
b'Ham',
'Bool':
True,
'UI8':
Uint8(42),
'UI16':
Uint16(4216),
'UI32':
Uint32(4232),
'UI64':
Uint64(4264),
'SI8':
Sint8(-42),
'SI16':
Sint16(-4216),
'SI32':
Sint32(-4232),
'SI64':
Sint64(-4264),
'R32':
Real32(42.0),
'R64':
Real64(42.64),
'DTI':
CIMDateTime(timedelta(10, 49, 20)),
'DTF':
cim_dt,
'DTP':
CIMDateTime(datetime(2014, 9, 22, 10, 49, 20, 524789,
tzinfo=TZ())),
}
# TODO python 2.7 will not write the following unicode character
# For the moment, only add this property in python 3 test
if six.PY3:
props_input['S2'] = u'H\u00E4m' # U+00E4 = lower case a umlaut
inst = CIMInstance('CIM_Foo', props_input)
return inst
def test_all(self):
self._run_single(CIMInstance('CIM_Foo'))
self._run_single(
CIMInstance(
'CIM_Foo', {
'string': 'string',
'uint8': Uint8(0),
'uint8array': [Uint8(1), Uint8(2)],
'ref': CIMInstanceName('CIM_Bar')
}))
self._run_single(
CIMInstance('CIM_Foo', {'InstanceID': '1234'},
path=CIMInstanceName('CIM_Foo',
{'InstanceID': '1234'})))
def make_instances(cls, number, value_profile):
"""
Construct and return a number of CIMInstance objects with path, with
random values for the instance properties.
"""
insts = []
for _ in range(0, number):
inst = CIMInstance(cls.classname)
# TODO: Make namespace flexible
inst.path = CIMInstanceName(cls.classname, namespace='root/cimv2')
for pname, cls_prop in cls.properties.items():
ptype = cls_prop.type
_, pvalue = random_type_value(value_profile, type=ptype)
inst_prop = CIMProperty(pname, type=ptype, value=pvalue)
inst.properties[pname] = inst_prop
if cls_prop.qualifiers.get('Key', False):
inst.path.keybindings[pname] = pvalue
insts.append(inst)
return insts
def test_close_export(self): # pylint: disable=no-self-use
"""
Test closing a connection and invoking an export operation.
"""
conn = WBEMConnection('http://localhost')
conn.close()
assert conn.session is None
indi = CIMInstance("CIM_AlertIndication")
with pytest.raises(ConnectionError) as exc_info:
conn.ExportIndication(NewIndication=indi)
exc = exc_info.value
assert re.match(r'is closed', str(exc))
def test_inst_to_yaml_array_props(self):
"""Test property with array toyaml"""
str_data = "The pink fox jumped over the big blue dog"
dt = datetime(2014, 9, 22, 10, 49, 20, 524789)
array_props = {
'MyString':
str_data,
'MyUint8Array': [Uint8(1), Uint8(2)],
'MySint8Array': [Sint8(1), Sint8(2)],
'MyUint64Array':
[Uint64(123456789),
Uint64(123456789),
Uint64(123456789)],
'MyUint32Array': [Uint32(9999), Uint32(9999)],
'MyDateTimeArray': [dt, dt, dt],
'MyStrLongArray': [str_data, str_data, str_data]
}
inst = CIMInstance('CIM_FooArray', array_props)
test_yaml = self.test_recorder.toyaml(inst)
self.assertEqual(test_yaml['pywbem_object'], 'CIMInstance')
self.assertEqual(test_yaml['classname'], 'CIM_FooArray')
properties = test_yaml['properties']
my_string = properties['MyString']
self.assertEqual(my_string['name'], 'MyString')
self.assertEqual(my_string['type'], 'string')
self.assertEqual(my_string['value'], str_data)
my_uint8array = properties['MyUint8Array']
self.assertEqual(my_uint8array['name'], 'MyUint8Array')
self.assertEqual(my_uint8array['type'], 'uint8')
self.assertEqual(my_uint8array['value'], [Uint8(1), Uint8(2)])
my_sint8array = properties['MySint8Array']
self.assertEqual(my_sint8array['name'], 'MySint8Array')
self.assertEqual(my_sint8array['type'], 'sint8')
self.assertEqual(my_sint8array['value'], [Sint8(1), Sint8(2)])
my_sint64array = properties['MyUint64Array']
self.assertEqual(my_sint64array['name'], 'MyUint64Array')
self.assertEqual(my_sint64array['type'], 'uint64')
self.assertEqual(
my_sint64array['value'],
[Uint64(123456789),
Uint64(123456789),
Uint64(123456789)])
my_datetimearray = properties['MyDateTimeArray']
self.assertEqual(my_datetimearray['name'], 'MyDateTimeArray')
self.assertEqual(my_datetimearray['type'], 'datetime')
cim_dt = str(CIMDateTime(dt))
self.assertEqual(my_datetimearray['value'], [cim_dt, cim_dt, cim_dt])
def test_all(self):
# Test instance
instance = CIMInstance('PyWBEM_Person', {
'CreationClassName': 'PyWBEM_Person',
'Name': 'Test'
},
path=CIMInstanceName(
'PyWBEM_Person', {
'CreationClassName': 'PyWBEM_Person',
'Name': 'Test'
}))
# Delete if already exists
try:
self.cimcall(self.conn.DeleteInstance, instance.path)
except CIMError as ce:
if ce.args[0] == CIM_ERR_NOT_FOUND:
pass
# Create instance
try:
self.cimcall(self.conn.CreateInstance, instance)
except CIMError as ce:
if ce.args[0] == CIM_ERR_INVALID_CLASS:
# does not support creation
pass
else:
# Modify instance
instance['Title'] = 'Sir'
instance.path.namespace = 'root/cimv2'
result = self.cimcall(self.conn.ModifyInstance, instance)
self.assertTrue(result is None)
# TODO add get and test for change.
# Clean up
self.cimcall(self.conn.DeleteInstance, instance.path)
def test_all(self):
# Test instance
instance = CIMInstance('PyWBEM_Person', {
'CreationClassName': 'PyWBEM_Person',
'Name': 'Test'
},
path=CIMInstanceName(
'PyWBEM_Person', {
'CreationClassName': 'PyWBEM_Person',
'Name': 'Test'
}))
# Delete if already exists (previous test incomplete)
try:
self.cimcall(self.conn.DeleteInstance, instance.path)
except CIMError as ce:
if ce.args[0] == CIM_ERR_NOT_FOUND:
pass
# Simple create and delete
try:
result = self.cimcall(self.conn.CreateInstance, instance)
except CIMError as ce:
if ce.args[0] == CIM_ERR_INVALID_CLASS:
# does not support creation
pass
else:
self.assertTrue(isinstance(result, CIMInstanceName))
self.assertTrue(len(result.namespace) > 0)
result = self.cimcall(self.conn.DeleteInstance, instance.path)
self.assertTrue(result is None)
try:
self.cimcall(self.conn.GetInstance(instance.path))
except CIMError as arg:
if arg == CIM_ERR_NOT_FOUND:
pass
def build_elementconformstoprofile_inst(self, conn, profile_path,
element_path):
"""
Build an instance of CIM_ElementConformsToProfile and insert into
repository
"""
class_name = 'CIM_ElementConformsToProfile'
element_conforms_dict = {
'ConformantStandard': profile_path,
'ManagedElement': element_path
}
# TODO modify this when issue #1540 (resolve qualifiers)fixed
# inst = self.inst_from_classname(conn, class_name,
# namespace=self.interop_ns,
# property_values=element_conforms_dict,
# include_missing_properties=False,
# include_path=True)
cls = conn.GetClass(class_name,
namespace=self.interop_ns,
LocalOnly=False,
IncludeQualifiers=True,
IncludeClassOrigin=True)
for pvalue in cls.properties.values():
if pvalue.type == 'reference':
if "key" not in pvalue.qualifiers:
pvalue.qualifiers['Key'] = \
CIMQualifier('Key', True, propagated=True)
inst = CIMInstance.from_class(cls,
namespace=self.interop_ns,
property_values=element_conforms_dict,
include_missing_properties=False,
include_path=True)
# TODO end of temp code
conn.add_cimobjects(inst, namespace=self.interop_ns)
assert conn.EnumerateInstances(class_name, namespace=self.interop_ns)
assert conn.GetInstance(inst.path)
def test_all(self):
# Single-valued properties
self._run_single(CIMProperty('Spotty', 'Foot'))
self._run_single(CIMProperty('Age', Uint16(32)))
self._run_single(CIMProperty('Foo', '', type='string'))
self._run_single(CIMProperty('Foo', None, type='string'))
self._run_single(
CIMProperty('Age',
None,
type='uint16',
qualifiers={'Key': CIMQualifier('Key', True)}))
# Property arrays
self._run_single(CIMProperty('Foo', ['a', 'b', 'c']))
self._run_single(CIMProperty('Foo', None, type='string',
is_array=True))
self._run_single(
CIMProperty('Foo', [Uint8(x) for x in [1, 2, 3]],
qualifiers={'Key': CIMQualifier('Key', True)}))
# Reference properties
self._run_single(CIMProperty('Foo', None, type='reference'))
self._run_single(CIMProperty('Foo', CIMInstanceName('CIM_Foo')))
self._run_single(
CIMProperty('Foo',
CIMInstanceName('CIM_Foo'),
qualifiers={'Key': CIMQualifier('Key', True)}))
# EmbeddedObject properties
inst = CIMInstance('Foo_Class', {'one': Uint8(1), 'two': Uint8(2)})
self._run_single(CIMProperty('Foo', inst))
self._run_single(CIMProperty('Foo', [inst]))
'element_conforms_to_profile': [
(('SNIA', 'Server', '1.2.0'), ("XXX_StorageComputerSystem", {
'Name':
"10.1.2.3",
'CreationClassName':
"XXX_StorageComputerSystem"
})),
],
# List of CIMInstances. Each entry is a CIM instance with classname,
# and properties. All properties required to build the path must be
# defined. No other properties are required for this test.
# TODO: We may expand this for more scoping tests.
'central-instances': [
CIMInstance('XXX_StorageComputerSystem',
properties={
'Name': "10.1.2.3",
'CreationClassName': "XXX_StorageComputerSystem",
'NameFormat': "IP"
}),
],
'scoping-instances': []
}
class WbemServerMock(object):
"""
Class that mocks the classes and methods used by the pywbem
WBEMServer class so that the WBEMServer class will produce valid data
for the server CIM_ObjectManager, CIM_Namespace, CIM_RegisteredProfile
instances.
This can be used to test the WbemServer class but is also required for
def inst_from_class(klass,
namespace=None,
property_values=None,
include_null_properties=True,
include_path=True,
strict=False,
include_class_origin=False):
"""
Build a new CIMInstance from the input CIMClass using the
property_values dictionary to complete properties and the other
parameters to filter properties, validate the properties, and
optionally set the path component of the CIMInstance. If any of the
properties in the class have default values, those values are passed
to the instance unless overridden by the property_values dictionary.
No CIMProperty qualifiers are included in the created instance and the
`class_origin` attribute is transfered from the class only if the
`include_class_origin` parameter is True
Parameters:
klass (:class:`pywbem:CIMClass`)
CIMClass from which the instance will be constructed. This
class must include qualifiers and should include properties
from any superclasses to be sure it includes all properties
that are to be built into the instance. Properties may be
excluded from the instance by not including them in the `klass`
parameter.
namespace (:term:`string`):
Namespace in the WBEMConnection used to retrieve the class or
`None` if the default_namespace is to be used.
property_values (dictionary):
Dictionary containing name/value pairs where the names are the
names of properties in the class and the properties are the
property values to be set into the instance. If a property is in
the property_values dictionary but not in the class an ValueError
exception is raised.
include_null_properties (:class:`py:bool`):
Determines if properties with Null values are included in the
instance.
If `True` they are included in the instance returned.
If `False` they are not included in the instance returned
inclued_class_origin (:class:`py:bool`):
Determines if ClassOrigin information is included in the returned
instance.
If None or False, class origin information is not included.
If True, class origin information is included.
include_path (:class:`py:bool`:):
If `True` the CIMInstanceName path is build and inserted into
the new instance. If `strict` all key properties must be in the
instance.
strict (:class:`py:bool`:):
If `True` and `include_path` is set, all key properties must be in
the instance so that
If not `True` The path component is created even if not all
key properties are in the created instance.
Returns:
Returns an instance with the defined properties and optionally
the path set. No qualifiers are included in the returned instance
and the existence of ClassOrigin depends on the
`include_class_origin` parameter. The value of each property is
either the value from the `property_values` dictionary, the
default_value from the class or Null(unless
`include_null_properties` is False). All other attributes of each
property are the same as the corresponding class property.
Raises:
ValueError if there are conflicts between the class and
property_values dictionary or strict is set and the class is not
complete.
"""
class_name = klass.classname
inst = CIMInstance(class_name)
for p in property_values:
if p not in klass.properties:
raise ValueError('Property Name %s in property_values but '
'not in class %s' % (p, class_name))
for cp in klass.properties:
ip = klass.properties[cp].copy()
ip.qualifiers = NocaseDict()
if not include_class_origin:
ip.class_origin = None
if ip.name in property_values:
ip.value = property_values[ip.name]
if include_null_properties:
inst[ip.name] = ip
else:
if ip.value:
inst[ip.name] = ip
if include_path:
inst.path = CIMInstanceName.from_instance(klass,
inst,
namespace,
strict=strict)
return inst
scope='module')
def status_tuple(request):
"""
Fixture representing variations of CIM status codes for initializing a
CIMError exception class.
Returns a tuple of positional arguments for initializing a CIMError
exception object.
"""
return request.param
@pytest.fixture(params=[
None,
[],
[CIMInstance('CIM_Err')],
[CIMInstance('CIM_Err1'), CIMInstance('CIM_Err2')],
],
scope='module')
def error_instances(request):
"""
Fixture representing variations of the list of instances that can be
set on a CIMError exception.
Returns a list of CIMInstance objects, or None.
"""
return request.param
def test_cimerror_1(status_tuple, conn_info):
# pylint: disable=redefined-outer-name
def test_objectstore(testcase, init_args, cls_kwargs, inst_kwargs, qual_kwargs):
# pylint: disable=unused-argument
"""
Simple test inserts one inst of defined type and tests retrievail
methods.
"""
namespace = "root/cimv2"
# Setup the ObjectStore
xxx_repo = InMemoryObjectStore(*init_args)
if cls_kwargs:
cls = CIMClass(**cls_kwargs)
if inst_kwargs:
inst = CIMInstance(**inst_kwargs)
inst.path = CIMInstanceName.from_instance(
cls, inst, namespace=namespace, host='me', strict=True)
if qual_kwargs:
qual = CIMQualifierDeclaration(**qual_kwargs)
# Is this instance or class test
if inst_kwargs:
name = inst.path
obj = inst
elif qual_kwargs:
name = qual.name
obj = qual
else:
name = cls.classname
obj = cls
# The code to be tested. The test include adding , getting, and deleting
# with the various inspection methods and testing for
# correct returns
# Create the object in the object store
xxx_repo.create(name, obj)
# confirm that exists works
assert xxx_repo.object_exists(name)
# Test repository object count; len()
assert xxx_repo.len() == 1
# Test get the object and test for same object
rtn_obj = xxx_repo.get(name)
# Test that the properties have changed indicating the deepcopy
# Uses only class and instance because we they have properties
if isinstance(obj, (CIMClass, CIMInstance)):
for prop in obj.properties:
assert rtn_obj.properties[prop] is not \
obj.properties[prop]
# Test same object return on two gets
rtn_obj2 = xxx_repo.get(name)
assert rtn_obj2 == rtn_obj
# Test that return with copy gets same object.
rtn_obj3 = xxx_repo.get(name, copy=True)
assert rtn_obj3 == obj
# Test that with copy=True the property ids have changed between the
# two gets indicating that the deepcopy was executed.
if isinstance(obj, (CIMClass, CIMInstance)):
for prop in obj.properties:
assert rtn_obj.properties[prop] is not \
rtn_obj3.properties[prop]
names = list(xxx_repo.iter_names())
assert len(names) == 1
assert names[0] == name
objs = list(xxx_repo.iter_values())
assert len(objs) == 1
assert objs[0] == obj
objs = list(xxx_repo.iter_values(copy=True))
assert len(objs) == 1
assert objs[0] == obj
if isinstance(obj, (CIMClass, CIMInstance)):
for prop in obj.properties:
assert objs[0].properties[prop] is not \
obj.properties[prop]
# Test update
# Test update; should work. Note that this test does not modify the
# object before creating the copy.
obj2 = obj.copy()
xxx_repo.update(name, obj2)
assert xxx_repo.get(name) == obj2
# Test valid delete of object
xxx_repo.delete(name)
assert not xxx_repo.object_exists(name)
assert xxx_repo.len() == 0
# Test errors
# Test update with unknown object; should fail
try:
xxx_repo.update(name, obj)
except KeyError:
pass
# Test delete nonexistent entity; should fail
try:
xxx_repo.delete(name)
assert False
except KeyError:
pass
# Test get non existent entity; should fail
try:
xxx_repo.get(name)
assert False
except KeyError:
pass
# Test exists; entity should not exist
assert not xxx_repo.object_exists(name)
# Test create with existing object
xxx_repo.create(name, obj)
# Test duplicate create; should fail
try:
xxx_repo.create(name, obj)
assert False
except ValueError:
pass
else:
with pytest.raises(exp_exc.__class__) as exec_info:
# The code to be tested
repo.remove_namespace(test_ns)
print(exec_info)
TEST_OBJECTS = [
CIMClass('Foo', properties=[
CIMProperty('P1', None, type='string',
qualifiers=[CIMQualifier('Key', value=True)])]),
CIMClass('Bar', properties=[
CIMProperty('P2', None, type='string',
qualifiers=[CIMQualifier('Key', value=True)])]),
CIMInstance('Foo', path=CIMInstanceName('Foo',
keybindings=NocaseDict(P1="P1"))),
CIMInstance('Bar', path=CIMInstanceName('Bar',
keybindings=NocaseDict(P2="P2"))),
CIMQualifierDeclaration('Qual1', type='string'),
CIMQualifierDeclaration('Qual2', type='string'), ]
TEST_OBJECTS2 = [
CIMClass('Foo', properties=[
CIMProperty('P2', None, type='string',
qualifiers=[CIMQualifier('Key', value=True)])]),
CIMInstance('Foo', path=CIMInstanceName('Foo',
keybindings=NocaseDict(P2="P2"))),
]
@pytest.mark.parametrize(
), None, None, True),
# Other CIM object tests
(
"Object is a CIMClass object",
dict(
obj=CIMClass('CIM_Foo'),
exp_type_name=u'string', # embedded object
),
None,
None,
True),
(
"Object is a CIMInstance object",
dict(
obj=CIMInstance('CIM_Foo'),
exp_type_name=u'string', # embedded object
),
None,
None,
True),
("Object is a CIMInstanceName object",
dict(
obj=CIMInstanceName('CIM_Foo'),
exp_type_name=u'reference',
), None, None, True),
("Object is a CIMClassName object",
dict(
obj=CIMClassName('CIM_Foo'),
exp_type_name=None,
), TypeError, None, True),
def test_all(self):
self._run_single(CIMInstance('CIM_Foo'))
self._run_single(CIMInstance('CIM_Foo', {'InstanceID': '1234'}))
def test_embeddedobject_properties(self):
"""Test EmbeddedObject properties"""
inst = CIMInstance('Foo_Class',
{'one': Uint8(1), 'two': Uint8(2)})
self._run_single(CIMProperty('Foo', inst))
self._run_single(CIMProperty('Foo', [inst]))
method='enumerateinstances',
args=[CIMInstanceName("CIM_Blah")],
kwargs={},
), TypeError, None, OK),
("Test GetInstance, invalid InstanceName tyhpe",
dict(
init_kwargs={},
method='getinstance',
args=[CIMClassName("CIM_Blah")],
kwargs={},
), TypeError, None, OK),
("Test ModifyInstance, No path in ModifiedInstance",
dict(
init_kwargs={},
method='modifyinstance',
args=[CIMInstance("CIMBlah")],
kwargs={},
), ValueError, None, OK),
("Test EnumerateInstances, Invalid args type",
dict(
init_kwargs={},
method='enumerateinstances',
args=[CIMClass("CIMBlah")],
kwargs={},
), TypeError, None, OK),
("Test OpenEnumerateInstances, Invalid type for operationtimeout",
dict(
init_kwargs={},
method='openenumerateinstances',
args=[CIMClass("CIMBlah")],
kwargs={"OperationTimeout": "shouldbeinteger"},
"""
Test file for use with wbemcli -mock-server parameter that adds an instance
to the mock repository
This file assumes that the file simple_mock_model.mof has already been loaded
so the class CIM_Foo exists.
"""
from __future__ import absolute_import, print_function
from ..utils import import_installed
pywbem = import_installed('pywbem') # noqa: E402
from pywbem import CIMInstance, CIMInstanceName
_INAME = 'CIM_Foo%s' % 'wbemcli_tst-1'
_INST_PATH = CIMInstanceName('CIM_Foo', {'InstanceID': _INAME})
_INST = CIMInstance('CIM_Foo',
properties={'InstanceID': _INAME},
path=_INST_PATH)
# CONN is a defined global variable in the wbemcli environment
global CONN # pylint: disable=global-at-module-level
CONN.add_cimobjects(_INST) # noqa: F821 pylint: disable=undefined-variable
# test that instance inserted
assert(CONN.GetInstance(_INST_PATH)) # noqa: F821,E501 pylint: disable=undefined-variable
def test_objectstore(testcase, init_args, cls_kwargs, inst_kwargs, qual_kwargs):
# pylint: disable=unused-argument
"""
Simple test inserts one inst of defined type and tests retrievail
methods.
"""
namespace = "root/cimv2"
# Setup the ObjectStore
xxx_repo = InMemoryObjectStore(*init_args)
if cls_kwargs:
cls = CIMClass(**cls_kwargs)
if inst_kwargs:
inst = CIMInstance(**inst_kwargs)
inst.path = CIMInstanceName.from_instance(
cls, inst, namespace=namespace, host='me', strict=True)
if qual_kwargs:
qual = CIMQualifierDeclaration(**qual_kwargs)
# is this instance or class test
if inst_kwargs:
name = inst.path
obj = inst
elif qual_kwargs:
name = qual.name
obj = qual
else:
name = cls.classname
obj = cls
# The code to be tested. The test include adding and testing the
# various inspection methods for correct returns
# Create the object in the object store
xxx_repo.create(name, obj)
# confirm that exists works
assert xxx_repo.exists(name)
# Test len()
assert xxx_repo.len() == 1
# Test get the object and test for same object
rtn_obj = xxx_repo.get(name)
assert rtn_obj == obj
names = [n for n in xxx_repo.iter_names()]
assert len(names) == 1
assert names[0] == name
objs = [x for x in xxx_repo.iter_values()]
assert len(objs) == 1
assert objs[0] == obj
# Test update
# Test update; should work
obj2 = obj.copy()
xxx_repo.update(name, obj2)
assert xxx_repo.get(name) == obj2
# Test valid delete of object
xxx_repo.delete(name)
assert not xxx_repo.exists(name)
assert xxx_repo.len() == 0
# Test errors
# Test update with unknown object; should fail
try:
xxx_repo.update(name, obj)
except KeyError:
pass
# Test delete nonexistent entity; should fail
try:
xxx_repo.delete(name)
assert False
except KeyError:
pass
# Test get non existent entity; should fail
try:
xxx_repo.get(name)
assert False
except KeyError:
pass
# Test exists; entity should not exist
assert not xxx_repo.exists(name)
# Test create with existing object
xxx_repo.create(name, obj)
# Test duplicate create; should fail
try:
xxx_repo.create(name, obj)
assert False
except ValueError:
pass
def build_referenced_profile_insts(self, server, referenced_profiles):
"""
Build and install in repository the referemced profile instances
defined by the referemces parameter. A dictionary of tuples where each
tuple contains Antecedent and Dependent reference in terms of the
profile name as a tuple (org, name, version).
Parameters:
conn:
profiles (dict of tuples where each tuple defines the antecedent
and dependent)
"""
class_name = 'CIM_ReferencedProfile'
for profile_name in referenced_profiles:
antecedent = profile_name[0]
dependent = profile_name[1]
antecedent_inst = server.get_selected_profiles(
registered_org=antecedent[0],
registered_name=antecedent[1],
registered_version=antecedent[2])
dependent_inst = server.get_selected_profiles(
registered_org=dependent[0],
registered_name=dependent[1],
registered_version=dependent[2])
assert len(antecedent_inst) == 1, \
"Antecedent: {0}".format(antecedent)
assert len(dependent_inst) == 1, \
"Dependent: {0}".format(dependent)
ref_profile_dict = {
'Antecedent': antecedent_inst[0].path,
'Dependent': dependent_inst[0].path
}
# TODO replace the setting of key qualifier with the commented
# code with #issue 1540 is fixed, i.e the key qualifier is
# included in the class.
# inst = self.inst_from_classname(server.conn, class_name,
# namespace=self.interop_ns,
# property_values=ref_profile_dict,
# include_missing_properties=False,
# include_path=True)
cls = server.conn.GetClass(class_name,
namespace=self.interop_ns,
LocalOnly=False,
IncludeQualifiers=True,
IncludeClassOrigin=True,
PropertyList=None)
for pvalue in cls.properties.values():
if pvalue.type == 'reference':
if "key" not in pvalue.qualifiers:
pvalue.qualifiers['Key'] = \
CIMQualifier('Key', True, propagated=True)
inst = CIMInstance.from_class(cls,
namespace=self.interop_ns,
property_values=ref_profile_dict,
include_missing_properties=False,
include_path=True)
# TODO end of code to drop for #1540 fix
server.conn.add_cimobjects(inst, namespace=self.interop_ns)
assert server.conn.EnumerateInstances(class_name,
namespace=self.interop_ns)
assert server.conn.GetInstance(inst.path)
def test_leaks_CIMInstance_minimal():
"""
Test function with a minimal CIMInstance object (i.e. no properties, no
qualifiers).
"""
_ = CIMInstance('CIM_Foo', )
