def test_cimtype(desc, kwargs, exp_exc_types, exp_warn_types, condition):
"""
All test cases for cimtype().
"""
obj = kwargs['obj']
# The code to be tested
type_name = cimtype(obj)
exp_type_name = kwargs['exp_type_name']
assert type_name == exp_type_name
def test_cimtype(testcase, obj, exp_type_name):
"""
Test function for cimtype().
"""
# The code to be tested
type_name = cimtype(obj)
# Ensure that exceptions raised in the remainder of this function
# are not mistaken as expected exceptions
assert testcase.exp_exc_types is None
assert type_name == exp_type_name
def pywbem2cmpi_data(self, pdata, _type=None):
is_array = isinstance(pdata, list)
if _type is None:
_type = pywbem.cimtype(pdata)
# This doesn't work below. cmpi.CMPIData() takes a CMPIData argument. ??
data = cmpi.CMPIData()
data.state = 0
data.type = _pywbem2cmpi_typemap[_type]
if is_array:
data.type = data.type | cmpi.CMPI_ARRAY
if _type == 'reference':
_type = 'ref'
pdata = self.pywbem2cmpi_instname(pdata)
self.pywbem2cmpi_value(pdata, _type, data.value)
return data
def test_cimtype(testcase, obj, exp_type_name):
"""
Test function for cimtype().
"""
# There are no init testcases covering all CIM types, so the following
# check is placed here.
# TODO: Create init testcaes for CIM types and move this check to there.
assert not hasattr(obj, '__dict__')
# The code to be tested
type_name = cimtype(obj)
# Ensure that exceptions raised in the remainder of this function
# are not mistaken as expected exceptions
assert testcase.exp_exc_types is None
assert type_name == exp_type_name
def pywbem2cmpi_value(self, pdata, _type=None, cval=None):
if pdata is None:
assert(_type is not None)
return None, _type
is_array = isinstance(pdata, list)
if _type is None:
if isinstance(pdata, pywbem.CIMInstance):
_type = 'instance'
elif isinstance(pdata, pywbem.CIMInstanceName):
_type = 'reference'
else:
_type = pywbem.cimtype(pdata)
attr = _type
if cval is None:
cval = cmpi.CMPIValue()
if is_array:
ralen = len(pdata)
ctype = _pywbem2cmpi_typemap[_type]
car = self.broker.new_array(ralen, ctype)
for i, rael in enumerate(pdata):
cv, tt = self.pywbem2cmpi_value(rael, _type=_type)
car.set(i, cv, ctype)
cval.array = car
return cval, _type
if _type == 'reference':
attr = 'ref'
pdata = self.pywbem2cmpi_instname(pdata)
elif _type == 'string':
pdata = self.broker.new_string(str(pdata))
elif _type == 'datetime':
attr = 'dateTime'
pdata = self.pywbem2cmpi_datetime(pdata)
elif _type == 'instance':
attr = 'inst'
pdata = self.pywbem2cmpi_inst(pdata)
elif _type == 'chars':
pdata = self.broker.new_string(str(pdata))
setattr(cval, attr, pdata)
return cval, _type
def InvokeMethod(self, methodname, localobject, params):
# pylint: disable=invalid-name
"""
Dispatcher for the InvokeMethod provider method.
This method performs validations and if successful, routes the provider
method call either to a registered provider, or to the default provider.
Parameters:
methodname (string): Method name
localobject (CIMInstanceName or CIMClassName): Target object, with
namespace set. Types are validated.
params (NocaseDict): Input parameters, as follows:
* key (string): Parameter name.
* value (CIMParameter): Parameter value.
Types are validated.
Returns:
A tuple of (returnvalue, outparams), with these tuple items:
* returnvalue (CIM data type): Return value.
* outparams (NocaseDict): Output parameters, with:
* key (string): Parameter name
* value (CIM data type): Parameter value
"""
namespace = localobject.namespace
# Verify the input parameter types (type errors have already been
# raised during checks in WBEMConnection.InvokeMethod(), and in
# FakedWBEMConnection._mock_methodcall()).
assert isinstance(namespace, six.string_types)
assert isinstance(methodname, six.string_types)
assert isinstance(localobject, (CIMInstanceName, CIMClassName))
assert isinstance(params, NocaseDict)
# Verify that the namespace exists in the CIM repository.
self.validate_namespace(namespace)
class_store = self.cimrepository.get_class_store(namespace)
instance_store = self.cimrepository.get_instance_store(namespace)
if isinstance(localobject, CIMInstanceName):
# instance-level use
# Get the creation class of the target instance from the CIM
# repository, verifying that it exists.
try:
klass = class_store.get(localobject.classname)
except KeyError:
raise CIMError(
CIM_ERR_INVALID_CLASS,
_format(
"Creation class {0!A} of target instance does "
"not exist in namespace {1!A} of the CIM "
"repository.", localobject.classname, namespace))
# Verify that the target instance exists in the CIM repository.
if not instance_store.object_exists(localobject):
raise CIMError(
CIM_ERR_NOT_FOUND,
_format(
"Target instance does not exist in the CIM "
"repository: {0!A}", localobject))
else:
assert isinstance(localobject, CIMClassName)
# class-level use
# Get the target class from the CIM repository, verifying that it
# exists.
try:
klass = class_store.get(localobject.classname)
except KeyError:
raise CIMError(
CIM_ERR_NOT_FOUND,
_format(
"Target class {0!A} does not exist in namespace "
"{1!A} of the CIM repository.", localobject.classname,
namespace))
# Verify that the class exposes the CIM method.
if methodname not in klass.methods:
raise CIMError(
CIM_ERR_METHOD_NOT_FOUND,
_format(
"Method {0!A} is not exposed by class {1!A} in "
"namespace {2!A} of the CIM repository.", methodname,
klass.classname, namespace))
method = klass.methods[methodname]
if isinstance(localobject, CIMClassName):
# class-level use
# Verify that the method is static.
# Note: A similar check for instance-level use is not appropriate
# because static methods can be invoked on instances or on classes.
static_qual = method.qualifiers.get('Static')
static_value = static_qual.value if static_qual else False
if not static_value:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"Non-static method {0!A} in class {1!A} in "
"namespace {2!A} cannot be invoked on a class "
"object.", methodname, klass.classname, namespace))
# Verify that the input parameters are defined by the method and have
# the correct type-related attributes.
for pn in params:
assert isinstance(pn, six.string_types)
param_in = params[pn]
assert isinstance(param_in, CIMParameter)
if pn not in method.parameters:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"The specified input parameter {0!A} is not "
"defined in method {1!A} of class {2!A} in "
"namespace {3!A} of the CIM repository", pn,
methodname, klass.classname, namespace))
param_cls = method.parameters[pn]
in_qual = method.qualifiers.get('In')
in_value = in_qual.value if in_qual else True
if not in_value:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"The specified input parameter {0!A} is "
"defined as an output-only parameter according to "
"its method {1!A} of class {2!A} in namespace "
"{3!A} of the CIM repository", pn, methodname,
klass.classname, namespace))
if param_in.type != param_cls.type:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"The specified input parameter {0!A} has "
"incorrect type={1!A}, but should have type={2!A} "
"according to its method {3!A} in class {4!A} in "
"namespace {5!A} of the CIM repository", pn,
param_in.type, param_cls.type, methodname,
klass.classname, namespace))
if param_in.is_array != param_cls.is_array:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"The specified input parameter {0!A} has "
"incorrect is_array={1!A}, but should have "
"is_array={2!A} "
"according to its method {3!A} in class {4!A} in "
"namespace {5!A} of the CIM repository", pn,
param_in.is_array, param_cls.is_array, methodname,
klass.classname, namespace))
if param_in.embedded_object != param_cls.embedded_object:
raise CIMError(
CIM_ERR_INVALID_PARAMETER,
_format(
"The specified input parameter {0!A} has "
"incorrect embedded_object={1!A}, but should have "
"embedded_object={2!A} "
"according to its method {3!A} in class {4!A} in "
"namespace {5!A} of the CIM repository", pn,
param_in.embedded_object, param_cls.embedded_object,
methodname, klass.classname, namespace))
# Determine the provider to be used.
provider = self.provider_registry.get_registered_provider(
namespace, 'method', klass.classname)
if not provider:
provider = self.default_method_provider
# Call the provider method
result = provider.InvokeMethod(methodname, localobject, params)
# Verify provider method result
if not isinstance(result, (list, tuple)):
raise TypeError(
_format(
"InvokeMethod provider method returned invalid type: "
"{0}. Must return list/tuple (return value, output "
"parameters)", type(result)))
if len(result) != 2:
raise ValueError(
_format(
"InvokeMethod provider method returned invalid number "
"of items: {0}. Must be list/tuple (return value, "
"output parameters)", len(result)))
return_value = result[0]
output_params = result[1]
# Map the more flexible way output parameters can be returned from
# the provider method to what _mock_methodcall() expects
output_params_dict = NocaseDict()
if isinstance(output_params, Sequence):
# sequence of CIMParameter
for param in output_params:
if not isinstance(param, CIMParameter):
raise TypeError(
_format(
"InvokeMethod provider method returned invalid "
"type for item in output parameters "
"sequence: {0}. Item type must be "
"CIMParameter", type(param)))
output_params_dict[param.name] = param.value
elif isinstance(output_params, Mapping):
# mapping of name:value or name:CIMParameter
for pname in output_params:
pvalue = output_params[pname]
if isinstance(pvalue, CIMParameter):
pvalue = pvalue.value
else:
# Perform check for valid CIM data type:
try:
cimtype(pvalue)
except TypeError:
new_exc = TypeError(
_format(
"InvokeMethod provider method returned "
"invalid type for value in output "
"parameters mapping: {0}. Value type must "
"be a CIM data type or CIMParameter",
type(pvalue)))
new_exc.__cause__ = None
raise new_exc
except ValueError:
# Empty array
pass
output_params_dict[pname] = pvalue
else:
raise TypeError(
_format(
"InvokeMethod provider method returned invalid type "
"for output parameters: {0}. Must be "
"Sequence(CIMParameter) or "
"Mapping(name: value/CIMParameter)", type(output_params)))
return return_value, output_params_dict
def test_conversions(proxy):
s = 'foo'
cs, _type = pywbem2cmpi_value(s)
assert(cs.string.__str__() == s)
assert(_type == 'string')
ns = cmpi2pywbem_value(cs, _type)
assert(s == ns)
#cdata = cmpi.CMPIData(None)
i = pywbem.Uint32(5)
ci, _type = pywbem2cmpi_value(i)
assert(_type == 'uint32')
assert(ci.uint32 == i)
ni = cmpi2pywbem_value(ci, _type)
assert(isinstance(ni, pywbem.Uint32))
assert(i == ni)
l = ['python','is','great']
cl, _type = pywbem2cmpi_value(l)
nl = cmpi2pywbem_value(cl, _type, is_array=True)
assert(nl == l)
l = [pywbem.Real32(3.4), pywbem.Real32(3.14159)]
cl, _type = pywbem2cmpi_value(l)
nl = cmpi2pywbem_value(cl, _type, is_array=True)
assert(_type == 'real32')
for i in xrange(0, len(l)):
assert(abs(l[i] - nl[i]) <= 0.001)
#print s == cmpi2pywbem_
pcop = pywbem.CIMInstanceName('Cmpi_Swig', namespace='root/cimv2',
keybindings={'k1':'A', 'k2':'B'})
ccop = pywbem2cmpi_instname(pcop)
ncop = cmpi2pywbem_instname(ccop)
assert(ncop.classname == 'Cmpi_Swig')
assert(ncop.namespace == 'root/cimv2')
assert(len(ncop.keybindings) == 2)
assert(ncop['k1'] == 'A')
assert(ncop['k2'] == 'B')
cinst = cmpi.CMPIInstance(proxy.broker, ccop)
assert(cinst.objectpath() is not None)
pinst = pywbem.CIMInstance('Cmpi_Swig', path=pcop,
properties={'k1':'A', 'k2':'B',
'p3':'string prop',
'p4':pywbem.Uint32(47)
})
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
assert(ninst.classname == pinst.classname)
pinst.properties['n'] = pywbem.CIMProperty('n', None, type='uint32')
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
#assert(ninst['n'] is None)
assert(ninst.classname == pinst.classname)
pinst['sint16'] = pywbem.Sint16(16)
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
assert(ninst['sint16'] == 16)
pinst['sint8'] = pywbem.Sint8(8)
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
assert(ninst['sint8'] == 8)
pinst['uint8a'] = [pywbem.Uint8(1), pywbem.Uint8(2), pywbem.Uint8(3)]
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
assert(ninst['uint8a'] == pinst['uint8a'])
pdt = pywbem.CIMDateTime.now()
cdt = pywbem2cmpi_datetime(pdt)
ndt = cmpi2pywbem_datetime(cdt)
assert(pdt == ndt)
cdt = proxy.broker.new_datetime_from_string('20080623144759.823564-360')
print '** ctd.is_interval()', cdt.is_interval()
print '** ctd.__str__()', cdt.__str__()
pinst['dt'] = pywbem.CIMDateTime('20080623144759.823564-360')
cinst = pywbem2cmpi_inst(pinst)
ninst = cmpi2pywbem_inst(cinst)
print '** ninst["dt"]', ninst['dt']
print '** pinst["dt"]', pinst['dt']
assert(ninst['dt'] == pinst['dt'])
pargs = {
'one':'one',
'two':pywbem.Uint32(43),
'three':pywbem.CIMDateTime.now(),
'four':['one','two','three'],
'five':[pywbem.CIMDateTime.now(), pywbem.CIMDateTime.now()],
'six':[pywbem.Sint32(-1), pywbem.Sint32(-2)]
}
iargs = dict([(k, (pywbem.cimtype(v), v)) for k, v in pargs.items()])
cargs = pywbem2cmpi_args(iargs)
nargs = cmpi2pywbem_args(cargs)
assert(pargs == nargs)
print '** tests passed'
