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 send_request_for_indications(conn, class_name, requested_indications): """ Send an invokemethod to the WBEM server to initiate the indication output. This is a pegasus specific operation. Note also that the way Pegasus works today, often the response for this request does not get returned until well after the indication flow has started because it operates on the same thread as the response. """ try: # Send method to pegasus server to create required number of # indications. This is a pegasus specific class and method result = conn.InvokeMethod( "SendTestIndicationsCount", class_name, [('indicationSendCount', Uint32(requested_indications))]) if result[0] != 0: print('SendTestIndicationCount Method error. Nonzero return=%s' \ % result[0]) return False return True except Error as er: print('Error: Indication Method exception %s' % er) return False
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('<PROPERTY NAME="Foo" TYPE="uint32"></PROPERTY>', CIMProperty('Foo', None, type='uint32')) self._run_single( '<PROPERTY NAME="Foo" TYPE="uint32"><VALUE>1234</VALUE>' '</PROPERTY>', CIMProperty('Foo', Uint32(1234))) self._run_single( '<PROPERTY NAME="Foo" TYPE="uint32">' '<QUALIFIER NAME="ASSOCIATION" TYPE="boolean">' '<VALUE>TRUE</VALUE></QUALIFIER><VALUE>1234</VALUE></PROPERTY>', CIMProperty( 'Foo', Uint32(1234), qualifiers={'ASSOCIATION': CIMQualifier('ASSOCIATION', True)}))
def test_invoke_method(self): """ Emulates call to invokemethod to test parameter processing. Currently creates the pywbem_request component. Each test emulated a single cim operation with fixed data to create the input for the yaml, create the yaml, and test the result """ obj_name = self.create_ciminstancename() params = [ ('StringParam', 'Spotty'), ('Uint8', Uint8(1)), ('Sint8', Sint8(2)), ('Uint16', Uint16(3)), ('Sint16', Sint16(3)), ('Uint32', Uint32(4)), ('Sint32', Sint32(5)), ('Uint64', Uint64(6)), ('Sint64', Sint64(7)), ('Real32', Real32(8)), ('Real64', Real64(9)), ('Bool', True), ('DTN', CIMDateTime.now()), # ('DTI', timedelta(60)), ('Ref', obj_name) ] self.test_recorder.stage_pywbem_args(method='InvokeMethod', MethodName='Blah', ObjectName=obj_name, Params=params) method_result_tuple = None method_exception = None self.test_recorder.stage_pywbem_result(method_result_tuple, method_exception) self.test_recorder.record_staged() # reload the yaml to test created values test_yaml = self.loadYamlFile() test_yaml = test_yaml[0] pywbem_request = test_yaml['pywbem_request'] self.assertEqual(pywbem_request['url'], 'http://acme.com:80') operation = pywbem_request['operation'] self.assertEqual(operation['pywbem_method'], 'InvokeMethod') self.assertEqual(operation['MethodName'], 'Blah') param_dict = dict(params) self.assertEqual(len(param_dict), 14) self.assertEqual(param_dict['StringParam'], 'Spotty') self.assertEqual(param_dict['Uint8'], 1) self.assertEqual(param_dict['Bool'], True) # test other parameters ref = param_dict['Ref'] self.assertEqual(ref, obj_name)
def test_all(self): self._run_single(CIMClass('CIM_Foo')) self._run_single(CIMClass('CIM_Foo', superclass='CIM_bar')) self._run_single(CIMClass( 'CIM_CollectionInSystem', qualifiers={'ASSOCIATION': CIMQualifier('ASSOCIATION', True, overridable=False), 'Aggregation': CIMQualifier('Aggregation', True, overridable=False), 'Version': CIMQualifier('Version', '2.6.0', tosubclass=False, translatable=False), 'Description': CIMQualifier('Description', 'CIM_CollectionInSystem is an ' \ 'association used to establish a ' \ 'parent-child relationship between a ' \ 'collection and an \'owning\' System ' \ 'such as an AdminDomain or '\ 'ComputerSystem. A single collection '\ 'should not have both a ' \ 'CollectionInOrganization and a ' \ 'CollectionInSystem association.', translatable=True)}, properties={'Parent': CIMProperty( 'Parent', None, type='reference', reference_class='CIM_System', qualifiers={'Key': CIMQualifier('Key', True, overridable=False), 'Aggregate': CIMQualifier('Aggregate', True, overridable=False), 'Max': CIMQualifier('Max', Uint32(1))}), 'Child': CIMProperty( 'Child', None, type='reference', reference_class='CIM_Collection', qualifiers={'Key': CIMQualifier('Key', True, overridable=False)} ) } ))
def test_all(self): self._run_single( '<QUALIFIER NAME="ASSOCIATION" TYPE="boolean"><VALUE>TRUE</VALUE>' '</QUALIFIER>', CIMQualifier('ASSOCIATION', True)) self._run_single( '<QUALIFIER NAME="Age" TYPE="uint32"><VALUE>1234</VALUE>' '</QUALIFIER>', CIMQualifier('Age', Uint32(1234))) self._run_single( '<QUALIFIER NAME="List" TYPE="uint8"><VALUE.ARRAY><VALUE>1</VALUE>' '<VALUE>2</VALUE><VALUE>3</VALUE><VALUE>4</VALUE></VALUE.ARRAY>' '</QUALIFIER>', CIMQualifier('List', [Uint8(i) for i in [1, 2, 3, 4]]))
def execute(self, url_type, timeout, delay): """ Execute a single connect with timeout, followed by invokemethod of the method that delays response and test for possible responses. Tests for correct response type (good response if the delay is less than the timeout and timeout exception if the delay is greater than the timeout. It ignores results where the operation delay and timeout are equal since the result could be either timeout or good response. """ url = url_type + '://' + self.host conn = self.connect(url, timeout=timeout) execution_time = None if self.debug: print('execute url_type=%s timeout=%s delay=%s' % (url_type, timeout, delay)) err_flag = "" opttimer = ElapsedTimer() try: # Confirm server working with a simple request. conn.GetClass('CIM_ManagedElement') request_result = 0 # good response conn.InvokeMethod(TESTMETHOD, TESTCLASS, [('delayInSeconds', Uint32(delay))]) execution_time = opttimer.elapsed_sec() if delay > timeout: err_flag = "Timeout Error: delay gt timeout" if self.stop_on_err: self.fail('should not get good response for %delay > %s' % (delay, timeout)) if delay == timeout: err_flag = "Good when timeout matches delay" # This exception terminates the test except ConnectionError as ce: request_result = 2 # Connection error received err_flag = "ConnectionError" execution_time = opttimer.elapsed_sec() self.fail('%s exception %s' % ('Failed ConnectionError)', ce)) # this exception tests against expected result. It terminates the # test only if the timeout is not expected except TimeoutError: execution_time = opttimer.elapsed_sec() err_flag = "TimeoutError" execution_time = opttimer.elapsed_sec() request_result = 1 # timeout error received # error if the operation delay is lt timeout value and we get # a timeout if delay < timeout: err_flag = 'Error. delay < timeout' if self.stop_on_err: self.fail('should not get timeout for %delay < %s' % (delay, timeout)) if delay == timeout: err_flag = "Timeout when timeout matches delay" # This exception terminates the test if stop_on_err set. except Exception as ec: # pylint: disable=broad-except err_flag = "Test Failed.General Exception" execution_time = opttimer.elapsed_sec() request_result = 2 if self.stop_on_err: self.fail('%s exception %s' % ('Failed(Exception)', ec)) # generate table entry if verbose. This defines result for this # test if self.verbose: request_result_txt = ['Good Rtn', 'Timeout ', 'Failure'] print('%-5s %-7s %7d %5d %10.2f %s' % (url_type, request_result_txt[request_result], timeout, delay, execution_time, err_flag)) return (True if request_result == 1 else False)
("Object is an integer", dict( obj=42, exp_type_name=None, ), TypeError, None, True), ("Object is a Uint8 number", dict( obj=Uint8(42), exp_type_name=u'uint8', ), None, None, True), ("Object is a Uint16 number", dict( obj=Uint16(42), exp_type_name=u'uint16', ), None, None, True), ("Object is a Uint32 number", dict( obj=Uint32(42), exp_type_name=u'uint32', ), None, None, True), ("Object is a Uint64 number", dict( obj=Uint64(42), exp_type_name=u'uint64', ), None, None, True), ("Object is a Sint8 number", dict( obj=Sint8(42), exp_type_name=u'sint8', ), None, None, True), ("Object is a Sint16 number", dict( obj=Sint16(42), exp_type_name=u'sint16',
def test_all(self): # Invoke on classname try: self.cimcall(self.conn.InvokeMethod, 'FooMethod', TEST_CLASS) except CIMError as ce: if ce.args[0] != CIM_ERR_METHOD_NOT_AVAILABLE: raise # Invoke on an InstanceName inst_names = self.cimcall(self.conn.EnumerateInstanceNames, TEST_CLASS) self.assertTrue(len(inst_names) >= 1) name = inst_names[0] # Pick the first returned instance try: self.cimcall(self.conn.InvokeMethod, 'FooMethod', name) except CIMError as ce: if ce.args[0] not in (CIM_ERR_METHOD_NOT_AVAILABLE, CIM_ERR_METHOD_NOT_FOUND): raise # Test remote instance name name2 = name.copy() name2.host = 'woot.com' name2.namespace = 'root/cimv2' try: self.cimcall(self.conn.InvokeMethod, 'FooMethod', name) except CIMError as ce: if ce.args[0] not in (CIM_ERR_METHOD_NOT_AVAILABLE, CIM_ERR_METHOD_NOT_FOUND): raise # Call with all possible parameter types try: self.cimcall(self.conn.InvokeMethod, 'FooMethod', TEST_CLASS, String='Spotty', Uint8=Uint8(1), Sint8=Sint8(2), Uint16=Uint16(3), Sint16=Sint16(3), Uint32=Uint32(4), Sint32=Sint32(5), Uint64=Uint64(6), Sint64=Sint64(7), Real32=Real32(8), Real64=Real64(9), Bool=True, Date1=CIMDateTime.now(), Date2=timedelta(60), Ref=name) except CIMError as ce: if ce.args[0] != CIM_ERR_METHOD_NOT_AVAILABLE: raise # Call with non-empty arrays try: self.cimcall(self.conn.InvokeMethod, 'FooMethod', TEST_CLASS, StringArray='Spotty', Uint8Array=[Uint8(1)], Sint8Array=[Sint8(2)], Uint16Array=[Uint16(3)], Sint16Array=[Sint16(3)], Uint32Array=[Uint32(4)], Sint32Array=[Sint32(5)], Uint64Array=[Uint64(6)], Sint64Array=[Sint64(7)], Real32Array=[Real32(8)], Real64Array=[Real64(9)], BoolArray=[False, True], Date1Array=[CIMDateTime.now(), CIMDateTime.now()], Date2Array=[timedelta(0), timedelta(60)], RefArray=[name, name]) except CIMError as ce: if ce.args[0] != CIM_ERR_METHOD_NOT_AVAILABLE: raise # Call with new Params arg try: self.cimcall( self.conn.InvokeMethod, 'FooMethod', TEST_CLASS, [('Spam', Uint16(1)), ('Ham', Uint16(2))], # Params Drink=Uint16(3), # begin of **params Beer=Uint16(4)) except CIMError as ce: if ce.args[0] != CIM_ERR_METHOD_NOT_AVAILABLE: raise