def test_tag_namespace(self): el = ent.Element('tag', self.adpt) self.assertEqual( el.element.tag, '{http://www.ibm.com/xmlns/systems/po' 'wer/firmware/uom/mc/2012_10/}tag') # entities.Element.tag strips the namespace self.assertEqual(el.tag, 'tag') self.assertEqual( el.namespace, 'http://www.ibm.com/xmlns/systems/powe' 'r/firmware/uom/mc/2012_10/') # Test setter el.tag = 'gat' self.assertEqual( el.element.tag, '{http://www.ibm.com/xmlns/systems/po' 'wer/firmware/uom/mc/2012_10/}gat') self.assertEqual(el.tag, 'gat') el.namespace = 'foo' self.assertEqual(el.namespace, 'foo') # Now with no namespace el = ent.Element('tag', self.adpt, ns='') self.assertEqual(el.element.tag, 'tag') self.assertEqual(el.tag, 'tag') self.assertEqual(el.namespace, '') el.tag = 'gat' self.assertEqual(el.element.tag, 'gat') self.assertEqual(el.tag, 'gat') el.namespace = 'foo' self.assertEqual(el.namespace, 'foo')
def test_cdata(self): no_cdata = ent.Element('tag', self.adpt, text='text', cdata=False) with_cdata = ent.Element('tag', self.adpt, text='text', cdata=True) self.assertEqual( no_cdata.toxmlstring(), '<uom:tag xmlns:uom="http://www.ibm.com/xmlns/systems/power/' 'firmware/uom/mc/2012_10/">text</uom:tag>'.encode('utf-8')) self.assertEqual( with_cdata.toxmlstring(), '<uom:tag xmlns:uom="http://www.ibm.com/xmlns/systems/power/firmwa' 're/uom/mc/2012_10/"><![CDATA[text]]></uom:tag>'.encode('utf-8'))
def test_subelement_not_in_ordering_list(self): """Subelement not in ordering list - should append.""" el = self._mk_el(self.all_children) ch = ent.Element('SomeNewElement', self.adpt, text='foo') el.inject(ch, ordering_list=self.ordering_list) self.assert_expected_children(el, self.child_at, self.child_unasi, self.child_rlpi1, self.child_rsn, ch)
def create_job_parameter(name, value, cdata=False): """Creates a JobParameter Element. :param name: ParameterName text value :param value: ParameterValue text value :param cdata: If True, the value text will be wrapped in CDATA tags :returns: JobParameter Element """ # JobParameter doesn't need adapter today adapter = None job_parm = ent.Element('JobParameter', adapter, attrib={'schemaVersion': 'V1_0'}, ns=pc.WEB_NS) job_parm.append(ent.Element('ParameterName', adapter, text=name, ns=pc.WEB_NS)) job_parm.append(ent.Element('ParameterValue', adapter, text=value, ns=pc.WEB_NS, cdata=cdata)) return job_parm
def _target_dev(self, vtd): """Sets the target device of this mapping. :param vtd: A {storage_type}TargetDev ElementWrapper representing the virtual target device to assign. """ vtd_elem = ent.Element(_MAP_TARGET_DEV, self.adapter, attrib={}, children=[]) vtd_elem.inject(vtd.element) self.inject(vtd_elem)
def setUp(self): super(TestMigration, self).setUp() self.adpt = self.useFixture(fx.AdapterFx()).adpt mock_resp = mock.MagicMock() mock_resp.entry = ent.Entry({}, ent.Element('Dummy', self.adpt), self.adpt) self.adpt.read.return_value = mock_resp self.lpar_w = mock.MagicMock() self.lpar_w.adapter = self.adpt self.lpar_w.uuid = '1234'
def test_repos_pv(self): repos = self.dwrap.repos_pv # PV is tested elsewhere. Minimal verification here. self.assertEqual(repos.name, 'hdisk2') # Test setter newrepos = stor.PV.wrap( ent.Element( "PhysicalVolume", None, attrib={'schemaVersion': 'V1_2_0'}, children=[ ent.Element('Metadata', None, children=[ent.Element('Atom', None)]), ent.Element('VolumeName', None, text='hdisk99')])) self.dwrap.repos_pv = newrepos self.assertEqual(self.dwrap.repos_pv.name, 'hdisk99') # Now try the same thing, but using factory constructor to build PV newrepos = stor.PV.bld(None, name='hdisk123') self.dwrap.repos_pv = newrepos self.assertAlmostEqual(self.dwrap.repos_pv.name, 'hdisk123')
def _backing_device(self, eth_back_dev): """The BackingDeviceChoice for this SEA. :param eth_back_dev: The EthernetBackingDevice for this BackingDeviceChoice. """ stor_elem = ent.Element(_SEA_BACKING_DEV, self.adapter, attrib={}, children=[]) stor_elem.inject(eth_back_dev.element) self.inject(stor_elem)
def backing_storage(self, stg): """Sets the backing storage of this mapping to a VDisk, VOpt, LU or PV. :param stg: Either a VDisk, VOpt, LU or PV wrapper representing the backing storage to assign. """ # Always replace. Because while the storage has one element, it can't # inject properly if the backing type changes (ex. cloning from vOpt to # vDisk). stor_elem = ent.Element(_MAP_STORAGE, self.adapter, attrib={}, children=[]) stor_elem.inject(stg.element) self.inject(stor_elem)
def test_clone_uuid(self, mock_run_job): mock_resp = mock.MagicMock() mock_resp.entry = ent.Entry( {}, ent.Element('Dummy', self.adpt), self.adpt) self.adpt.read.side_effect = [mock_resp] mock_run_job.side_effect = tju.get_parm_checker( self, '1234', [('targetLparName', 'abc')]) tpar.clone_uuid(self.adpt, '1234', 'abc') self.adpt.read.assert_called_once_with('LogicalPartition', root_id='1234', suffix_type='do', suffix_parm='CloneUUID')
def test_close_vterm_non_local(self, mock_run_job): """Performs a close LPAR vterm test.""" mock_resp = mock.MagicMock() mock_resp.entry = ent.Entry({}, ent.Element('Dummy', self.adpt), self.adpt) self.adpt.read.return_value = mock_resp vterm._close_vterm_non_local(self.adpt, '12345') self.assertEqual(1, mock_run_job.call_count) self.assertEqual(1, self.adpt.read.call_count) # test exception path mock_run_job.side_effect = pexc.LPARNotFound(lpar_name='12345') self.assertRaises(pexc.LPARNotFound, vterm._close_vterm_non_local, self.adpt, '12345') mock_run_job.reset_mock()
def _rebuild_vnet_list(self): """A callback from the Load Group to rebuild the virtual network list. Needed due to the API using both the LoadGroup and Network Bridge as a source. But usage at an API level should be through Load Groups. """ # Find all the children Virtual Networks. search = u.xpath(_NB_LGS, _NB_LG, _NB_VNETS, c.LINK) new_vnets = copy.deepcopy(self.element.findall(search)) # Find and replace the current element. cur_vnets = self.element.find(_NB_VNETS) self.element.replace( cur_vnets, ent.Element(_NB_VNETS, self.adapter, children=new_vnets))
def test_element_iter(self): """Test the ETElement iter() method found in the Adapter class.""" # Init test data children = [ ent.Element('Type1', None, text='T1_0'), ent.Element('Type12', None, text='T12_0'), ent.Element('Type1', None, text='T1_1'), ent.Element('Type12', None, text='T12_1'), ent.Element('Type1', None, text='T1_2') ] top_element = ent.Element('Top', None, attrib={'schemaVersion': 'V1_0'}, children=children) def _count_elem(top, tag, it=None, assert_tag=True): elem_count = 0 it = it if it else top.iter(tag=tag) for elem in it: if assert_tag: self.assertEqual(elem.tag, tag) elem_count += 1 return elem_count # Run the actual tests # Ensure all elements are traversed if we don't specify a tag self.assertEqual( _count_elem(top_element, 'Type1', it=top_element.iter(), assert_tag=False), 6) # Ensure all elements are traversed for tag=* self.assertEqual( _count_elem(top_element, 'Type1', it=top_element.iter(tag='*'), assert_tag=False), 6) # Ensure all elements are traversed for tag=None self.assertEqual( _count_elem(top_element, 'Type1', it=top_element.iter(tag=None), assert_tag=False), 6) # Get only the Type1 elements self.assertEqual(_count_elem(top_element, 'Type1'), 3) # Get only the top self.assertEqual(_count_elem(top_element, 'Top'), 1)
def setUp(self): super(TestElementInject, self).setUp() self.adpt = self.useFixture(fx.AdapterFx()).adpt self.ordering_list = ('AdapterType', 'UseNextAvailableSlotID', 'RemoteLogicalPartitionID', 'RemoteSlotNumber') self.child_at = ent.Element('AdapterType', self.adpt, text='Client') self.child_unasi = ent.Element('UseNextAvailableSlotID', self.adpt, text='true') self.child_rlpi1 = ent.Element('RemoteLogicalPartitionID', self.adpt, text='1') self.child_rlpi2 = ent.Element('RemoteLogicalPartitionID', self.adpt, text='2') self.child_rlpi3 = ent.Element('RemoteLogicalPartitionID', self.adpt, text='3') self.child_rsn = ent.Element('RemoteSlotNumber', self.adpt, text='12') self.all_children = [ self.child_at, self.child_unasi, self.child_rlpi1, self.child_rsn ]
def setUp(self): super(TestMemory, self).setUp() entry = ent.Entry({}, ent.Element('Dummy', None), None) self.mock_job = job.Job(entry) self.adpt = self.useFixture(fx.AdapterFx()).adpt
def _mk_el(self, children): return ent.Element('VirtualSCSIClientAdapter', self.adpt, attrib={'schemaVersion': 'V1_0'}, children=children)
def setUp(self): super(TestPower, self).setUp() mock_resp = mock.MagicMock() mock_resp.entry = ent.Entry({}, ent.Element('Dummy', None), None) self.adpt = self.useFixture(fx.AdapterFx()).adpt self.adpt.read.return_value = mock_resp
def _lua_recovery_xml(itls, adapter, vendor=LUAType.OTHER): """Builds the XML that is used as input for the lua_recovery job. The lua_recovery provides a very quick way for the system to discover an hdisk on the system. This method builds the input into the lua_recovery job. :param itls: The list of ITL objects that define the various connections between the server port (initiator), disk port (target) and disk itself. :param vendor: The LUA vendor. See the LUAType.* Constants. :return: The CDATA XML that is used for the lua_recovery job. """ # Used for building the internal XML. root = ent.Element("XML_LIST", adapter, ns='') # The general attributes # TODO(IBM) Need to determine value of making these constants modifiable general = ent.Element("general", adapter, ns='') general.append(ent.Element("cmd_version", adapter, text=_LUA_CMD_VERSION, ns='')) general.append(ent.Element("version", adapter, text=_LUA_VERSION, ns='')) root.append(general) # TODO(IBM) This can be re-evaluated. Set to true if you know for sure # the ITLs are alive. If there are any bad ITLs, this should be false. root.append(ent.Element("reliableITL", adapter, text="false", ns='')) # There is only one device in the device list. device_list = ent.Element("deviceList", adapter, ns='') device = ent.Element("device", adapter, ns='') device.append(ent.Element("vendor", adapter, text=vendor, ns='')) device.append(ent.Element("deviceTag", adapter, text="1", ns='')) itl_list = ent.Element("itlList", adapter, ns='') itl_list.append(ent.Element("number", adapter, text="%d" % (len(itls)), ns='')) for itl in itls: itl_elem = ent.Element("itl", adapter, ns='') itl_elem.append(ent.Element("Iwwpn", adapter, text=itl.initiator, ns='')) itl_elem.append(ent.Element("Twwpn", adapter, text=itl.target, ns='')) itl_elem.append(ent.Element("lua", adapter, text=itl.lun, ns='')) itl_list.append(itl_elem) device.append(itl_list) device_list.append(device) root.append(device_list) return root.toxmlstring().decode('utf-8')