Commit eb73d8d8 authored by Romain Courteaud's avatar Romain Courteaud

Dead code.

parent dd275237
...@@ -110,15 +110,6 @@ class TestVifibFiberSubscription(testVifibSecurityMixin): ...@@ -110,15 +110,6 @@ class TestVifibFiberSubscription(testVifibSecurityMixin):
fiber_request = pending_request_list[0] fiber_request = pending_request_list[0]
sequence.edit(fiber_request_url=fiber_request.getRelativeUrl()) sequence.edit(fiber_request_url=fiber_request.getRelativeUrl())
def stepStartFiberRequest(self,sequence=None,sequence_list=None, **kw):
"""Start the fiber request present in sequence"""
fiber_request_url = sequence.get("fiber_request_url")
fiber_request = self.getPortal().restrictedTraverse(fiber_request_url)
self.modifyFiberRequestState("start_action",sequence,fiber_request)
self.assertEquals(fiber_request.getValidationState(), 'started')
def stepConfirmFiberRequest(self,sequence=None,sequence_list=None, **kw): def stepConfirmFiberRequest(self,sequence=None,sequence_list=None, **kw):
"""Confirm the fiber request present in sequence""" """Confirm the fiber request present in sequence"""
fiber_request_url = sequence.get("fiber_request_url") fiber_request_url = sequence.get("fiber_request_url")
......
...@@ -135,9 +135,6 @@ class TestVifibSlapBug(TestVifibSlapWebServiceMixin): ...@@ -135,9 +135,6 @@ class TestVifibSlapBug(TestVifibSlapWebServiceMixin):
def stepRestoreSoftwareInstanceUidFromBufferA(self, sequence, **kw): def stepRestoreSoftwareInstanceUidFromBufferA(self, sequence, **kw):
sequence['software_instance_uid'] = sequence['buffer_a_software_instance_uid'] sequence['software_instance_uid'] = sequence['buffer_a_software_instance_uid']
def stepRestoreSoftwareInstanceUidFromBufferB(self, sequence, **kw):
sequence['software_instance_uid'] = sequence['buffer_b_software_instance_uid']
def stepRestoreComputerUidFromBufferA(self, sequence, **kw): def stepRestoreComputerUidFromBufferA(self, sequence, **kw):
sequence['computer_uid'] = sequence['buffer_a_computer_uid'] sequence['computer_uid'] = sequence['buffer_a_computer_uid']
...@@ -171,15 +168,9 @@ class TestVifibSlapBug(TestVifibSlapWebServiceMixin): ...@@ -171,15 +168,9 @@ class TestVifibSlapBug(TestVifibSlapWebServiceMixin):
def stepRestoreComputerPartitionUidFromBufferA(self, sequence, **kw): def stepRestoreComputerPartitionUidFromBufferA(self, sequence, **kw):
sequence['computer_partition_uid'] = sequence['buffer_a_computer_partition_uid'] sequence['computer_partition_uid'] = sequence['buffer_a_computer_partition_uid']
def stepRestoreComputerPartitionUidFromBufferB(self, sequence, **kw):
sequence['computer_partition_uid'] = sequence['buffer_b_computer_partition_uid']
def stepRestoreComputerPartitionReferenceFromBufferA(self, sequence, **kw): def stepRestoreComputerPartitionReferenceFromBufferA(self, sequence, **kw):
sequence['computer_partition_reference'] = sequence['buffer_a_computer_partition_reference'] sequence['computer_partition_reference'] = sequence['buffer_a_computer_partition_reference']
def stepRestoreComputerPartitionReferenceFromBufferB(self, sequence, **kw):
sequence['computer_partition_reference'] = sequence['buffer_b_computer_partition_reference']
def stepCheckHostingSubscriptionMultipleComputerAuditor(self, sequence, **kw): def stepCheckHostingSubscriptionMultipleComputerAuditor(self, sequence, **kw):
hosting_subscription = self.portal.portal_catalog.getResultValue( hosting_subscription = self.portal.portal_catalog.getResultValue(
uid=sequence['hosting_subscription_uid']) uid=sequence['hosting_subscription_uid'])
......
...@@ -172,19 +172,6 @@ class TestVifibSlapComputerGetComputerPartitionList(TestVifibSlapWebServiceMixin ...@@ -172,19 +172,6 @@ class TestVifibSlapComputerGetComputerPartitionList(TestVifibSlapWebServiceMixin
sequence_list.addSequenceString(sequence_string) sequence_list.addSequenceString(sequence_string)
sequence_list.play(self) sequence_list.play(self)
def stepDeliverInstanceSetupSalePackingList(self, sequence, **kw):
delivery = self.portal.portal_catalog.getResultValue(
default_aggregate_uid=ComplexQuery(
Query(default_aggregate_uid=sequence['computer_partition_uid']),
Query(default_aggregate_uid=sequence['software_instance_uid']),
operator="AND"),
portal_type=self.sale_packing_list_line_portal_type,
simulation_state='stopped',
resource_relative_url=self.portal.portal_preferences\
.getPreferredInstanceSetupResource()
).getParentValue()
self.portal.portal_workflow.doActionFor(delivery, 'deliver_action')
def test_Computer_getComputerPartitionList_HostingResource_ConfirmedState(self): def test_Computer_getComputerPartitionList_HostingResource_ConfirmedState(self):
""" """
Check that calling Computer.getComputerPartitionList works in Check that calling Computer.getComputerPartitionList works in
......
...@@ -251,9 +251,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -251,9 +251,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
software_release_url=sequence['software_release_uri'], software_release_url=sequence['software_release_uri'],
free_for_request=1)[0][0] free_for_request=1)[0][0]
def stepCheckSoftwareReleaseAvailableForRequest(self, sequence, **kw):
self.assertNotEqual(0, self._getRequestBasedComputerPartitionCount(sequence))
def stepCheckSoftwareReleaseUnavailableForRequest(self, sequence, **kw): def stepCheckSoftwareReleaseUnavailableForRequest(self, sequence, **kw):
self.assertEqual(0, self._getRequestBasedComputerPartitionCount(sequence)) self.assertEqual(0, self._getRequestBasedComputerPartitionCount(sequence))
...@@ -267,9 +264,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -267,9 +264,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
request.set('portal_skin', "View") request.set('portal_skin', "View")
return amount return amount
def stepCheckSoftwareReleaseInPublicTable(self, sequence, **kw):
self.assertNotEqual(0, self._getSoftwareReleasePublicTableAmount(sequence))
def stepCheckSoftwareReleaseNotInPublicTable(self, sequence, **kw): def stepCheckSoftwareReleaseNotInPublicTable(self, sequence, **kw):
self.assertEqual(0, self._getSoftwareReleasePublicTableAmount(sequence)) self.assertEqual(0, self._getSoftwareReleasePublicTableAmount(sequence))
...@@ -344,23 +338,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -344,23 +338,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
portal_type='Sale Order Line').getAggregateValue( portal_type='Sale Order Line').getAggregateValue(
portal_type='Hosting Subscription').getUid()) portal_type='Hosting Subscription').getUid())
def stepSelectSoftwareInstanceFromCurrentSlaveInstance(self, sequence):
slave_instance_reference = sequence["software_instance_reference"]
slave_instance = self.portal.portal_catalog.getResultValue(
portal_type=self.slave_instance_portal_type,
reference=slave_instance_reference)
computer_partition = slave_instance.getAggregateRelatedValue(
portal_type="Sale Packing List Line").getAggregateValue(
portal_type="Computer Partition")
software_instance = self.portal.portal_catalog.getResultValue(
portal_type="Sale Packing List Line",
aggregate_uid=computer_partition.getUid(),
aggregatep_portal_type=self.software_instance_portal_type,
).getAggregateValue(portal_type=self.software_instance_portal_type)
sequence.edit(
software_instance_uid=software_instance.getUid(),
software_instance_reference=software_instance.getReference())
def stepSetCurrentPersonSlapRequestedSoftwareInstance(self, sequence, **kw): def stepSetCurrentPersonSlapRequestedSoftwareInstance(self, sequence, **kw):
software_instance_list = [] software_instance_list = []
for software_instance in self.portal.portal_catalog( for software_instance in self.portal.portal_catalog(
...@@ -464,12 +441,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -464,12 +441,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
def stepSetSoftwareTitleRandom(self, sequence, **kw): def stepSetSoftwareTitleRandom(self, sequence, **kw):
sequence['software_title'] = str(random()) sequence['software_title'] = str(random())
def stepCheckComputerPartitionInstanceCleanupSalePackingListDoesNotExists(self,
sequence, **kw):
self._checkComputerPartitionSalePackingListDoesNotExists(
self.portal.portal_preferences.getPreferredInstanceCleanupResource(),
sequence)
def stepCheckComputerPartitionInstanceCleanupSalePackingListConfirmed(self, def stepCheckComputerPartitionInstanceCleanupSalePackingListConfirmed(self,
sequence, **kw): sequence, **kw):
self._checkComputerPartitionSalePackingListState('confirmed', self._checkComputerPartitionSalePackingListState('confirmed',
...@@ -518,13 +489,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -518,13 +489,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.portal.portal_preferences.getPreferredInstanceHostingResource(), self.portal.portal_preferences.getPreferredInstanceHostingResource(),
sequence) sequence)
def stepCheckComputerPartitionAccoutingResourceSalePackingListCancelled(self,
sequence, **kw):
self._checkComputerPartitionSalePackingListState('cancelled',
self.portal.portal_catalog.getResultValue(
uid=sequence['service_uid']).getRelativeUrl(),
sequence)
def stepPersonRequestSlaveInstance(self, sequence, **kw): def stepPersonRequestSlaveInstance(self, sequence, **kw):
kw = dict(instance_portal_type=self.slave_instance_portal_type, kw = dict(instance_portal_type=self.slave_instance_portal_type,
shared=True, shared=True,
...@@ -641,23 +605,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -641,23 +605,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
shared=shared, shared=shared,
) )
def stepRequestSoftwareInstanceStartRaisesValueError(self, sequence, **kw):
instance = self.portal.portal_catalog.getResultValue(
uid=sequence['software_instance_uid'])
if instance.getPortalType() == "Software Instance":
shared = False
elif instance.getPortalType() == "Slave Instance":
shared = True
else:
raise NotImplementedError
self.assertRaises(ValueError, instance.requestDestroy,
software_release=instance.getRootSoftwareReleaseUrl(),
instance_xml=instance.getTextContent(),
software_type=instance.getSourceReference(),
sla_xml=instance.getSlaXml(),
shared=shared,
)
def stepRequestSoftwareInstanceStop(self, sequence, **kw): def stepRequestSoftwareInstanceStop(self, sequence, **kw):
instance = self.portal.portal_catalog.getResultValue( instance = self.portal.portal_catalog.getResultValue(
uid=sequence['software_instance_uid']) uid=sequence['software_instance_uid'])
...@@ -1339,30 +1286,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1339,30 +1286,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
) )
self.assertEquals(0, len(result_list)) self.assertEquals(0, len(result_list))
def stepCheckDraftComputerState(self, sequence, **kw):
"""
Check that computer document is draft.
"""
computer_uid = sequence["computer_uid"]
computer = self.portal.portal_catalog.getResultValue(uid=computer_uid)
self.assertEquals("draft", computer.getValidationState())
def stepValidateComputer(self, sequence, **kw):
"""
Validate the computer document.
"""
computer_uid = sequence["computer_uid"]
computer = self.portal.portal_catalog.getResultValue(uid=computer_uid)
computer.validate()
def stepCheckValidatedComputerState(self, sequence, **kw):
"""
Check that computer document is validated.
"""
computer_uid = sequence["computer_uid"]
computer = self.portal.portal_catalog.getResultValue(uid=computer_uid)
self.assertEquals("validated", computer.getValidationState())
def stepCheckUnauthorizedSlapGetComputerPartitionListCall(self, sequence, def stepCheckUnauthorizedSlapGetComputerPartitionListCall(self, sequence,
**kw): **kw):
computer_guid = sequence.get("computer_reference", str(random())) computer_guid = sequence.get("computer_reference", str(random()))
...@@ -1393,30 +1316,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1393,30 +1316,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertRaises(slap.NotFoundError, self.assertRaises(slap.NotFoundError,
self.slap.registerComputerPartition, computer_guid, partition_id) self.slap.registerComputerPartition, computer_guid, partition_id)
def stepSelect0QuantityComputerPartition(self, sequence, **kw):
sequence.edit(computer_partition_quantity=0)
def stepSelectCurrentComputerPartitionAsSlaveOwner(self, sequence, **kw):
computer_partition_uid = sequence["computer_partition_uid"]
self.assertNotEqual(None, computer_partition_uid)
sequence.edit(slave_owner_uid=computer_partition_uid)
def stepCreateComputerPartition(self, sequence, **kw):
"""
Create a computer partition document.
"""
computer_uid = sequence["computer_uid"]
partition_reference = sequence["computer_partition_reference"]
computer = self.portal.portal_catalog.getResultValue(uid=computer_uid)
computer_partition = computer.newContent(
portal_type=self.computer_partition_portal_type,
reference=partition_reference)
self.markManualCreation(computer_partition)
# Mark newly created computer partition as free by default
computer_partition.markFree()
sequence.edit(computer_partition_uid=computer_partition.getUid())
def stepCheckSuccessSlapRegisterComputerPartitionCall(self, sequence, **kw): def stepCheckSuccessSlapRegisterComputerPartitionCall(self, sequence, **kw):
""" """
Check that slap.registerComputerPartition is successfully called. Check that slap.registerComputerPartition is successfully called.
...@@ -1527,17 +1426,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1527,17 +1426,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.markManualCreation(software_release) self.markManualCreation(software_release)
sequence.edit(software_release_uid=software_release.getUid()) sequence.edit(software_release_uid=software_release.getUid())
def stepCheckUnexistingSoftwareRelease(self, sequence, **kw):
"""
Check that it is not present in the system.
"""
url = sequence["software_release_uri"]
result_list = self.portal.portal_catalog(
portal_type=self.software_release_portal_type,
url_string=url,
)
self.assertEquals(0, len(result_list))
def stepSetSoftwareProductToSoftwareRelease(self, sequence, **kw): def stepSetSoftwareProductToSoftwareRelease(self, sequence, **kw):
""" """
Associate software product to software release Associate software product to software release
...@@ -1562,15 +1450,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1562,15 +1450,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
software_release.portal_workflow.doActionFor(software_release, software_release.portal_workflow.doActionFor(software_release,
'submit_action') 'submit_action')
def stepPublishSoftwareRelease(self, sequence, **kw):
"""
Validate the software release document.
"""
software_release_uid = sequence["software_release_uid"]
software_release = self.portal.portal_catalog.getResultValue(
uid=software_release_uid)
software_release.publish()
def stepPublishByActionSoftwareRelease(self, sequence, **kw): def stepPublishByActionSoftwareRelease(self, sequence, **kw):
""" """
Validate the software release document. Validate the software release document.
...@@ -1581,40 +1460,9 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1581,40 +1460,9 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
software_release.portal_workflow.doActionFor(software_release, software_release.portal_workflow.doActionFor(software_release,
'publish_action') 'publish_action')
def stepCheckDraftSoftwareReleaseState(self, sequence, **kw):
"""
Check that software release is draft.
"""
software_release_uid = sequence["software_release_uid"]
software_release = self.portal.portal_catalog.getResultValue(
uid=software_release_uid)
self.assertEquals("draft", software_release.getValidationState())
def stepCheckPublishedSoftwareReleaseState(self, sequence, **kw):
"""
Check that software release is validated.
"""
software_release_uid = sequence["software_release_uid"]
software_release = self.portal.portal_catalog.getResultValue(
uid=software_release_uid)
self.assertEquals("published", software_release.getValidationState())
def stepCheckNotFoundComputerGetComputerPartitionCall(self, sequence, **kw):
"""
Check that Computer.getComputerPartitionList is successfully called.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
self.assertRaises(slap.NotFoundError, computer.getComputerPartitionList)
def stepSelectYetAnotherRequestedReference(self, sequence, **kw): def stepSelectYetAnotherRequestedReference(self, sequence, **kw):
sequence.edit(requested_reference='yet_another_requested_reference') sequence.edit(requested_reference='yet_another_requested_reference')
def stepSelectYetAnotherRequestedSoftwareType(self, sequence, **kw):
sequence.edit(requested_software_type='yet_another_requested_software_type')
def stepSelectAnotherRequestedReference(self, sequence, **kw): def stepSelectAnotherRequestedReference(self, sequence, **kw):
sequence.edit(requested_reference='another_requested_reference') sequence.edit(requested_reference='another_requested_reference')
...@@ -1862,144 +1710,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -1862,144 +1710,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
sequence.edit(software_instance_uid=root_software_instance_uid, sequence.edit(software_instance_uid=root_software_instance_uid,
computer_partition_reference=computer_partition_reference) computer_partition_reference=computer_partition_reference)
def stepRequestComputerPartitionDifferentReferenceSameTransaction(self,
sequence, **kw):
software_release_uri = sequence['software_release_uri']
computer_guid = sequence["computer_reference"]
requested_parameter_dict = sequence['requested_parameter_dict']
software_instance_uid = sequence['software_instance_uid']
software_instance = self.portal.portal_catalog.getResultValue(
uid=software_instance_uid)
# Slap Tool have to be used directly to simulate same transaction
raise NotImplementedError("Do not test slap tool but slap library")
children_software_instance = software_instance\
.SoftwareInstance_findAlreadyExisting('children_a')
slap_tool_response = self.portal.portal_slap.requestComputerPartition(
computer_guid, children_software_instance\
.SoftwareInstance_getComputerPartition().getReference(),
software_release_uri, 'children_a_child',
requested_parameter_dict)
self.assertEqual(408, slap_tool_response.getStatus())
children_software_instance = software_instance\
.SoftwareInstance_findAlreadyExisting('children_b')
slap_tool_response = self.portal.portal_slap.requestComputerPartition(
computer_guid, children_software_instance\
.SoftwareInstance_getComputerPartition().getReference(),
software_release_uri, 'children_b_child',
requested_parameter_dict)
self.assertEqual(408, slap_tool_response.getStatus())
def stepRequestComputerPartitionSameReferenceSameTransaction(self, sequence,
**kw):
raise NotImplementedError('Wrong logic')
software_release_uri = sequence['software_release_uri']
requested_reference = sequence['requested_reference']
computer_guid = sequence["computer_reference"]
requested_parameter_dict = sequence['requested_parameter_dict']
software_instance_uid = sequence['software_instance_uid']
software_instance = self.portal.portal_catalog.getResultValue(
uid=software_instance_uid)
self.slap = slap.slap()
# Slap Tool have to be used directly to simulate same transaction
children_software_instance = \
software_instance.portal_catalog.getResultValue(
portal_type="Software Instance", source_reference='children_a',
root_uid=software_instance_uid)
movement = children_software_instance.getAggregateRelatedValue(
portal_type="Sale Packing List Line")
children_partition = movement.getAggregateValue(
portal_type="Computer Partition")
slap_computer_partition = self.slap.registerComputerPartition(
computer_guid,
children_partition.getReference())
slap_computer_partition.request(
software_release=software_release_uri, software_type=requested_reference,
partition_reference=requested_reference,
partition_parameter_kw=requested_parameter_dict)
children_software_instance = \
software_instance.portal_catalog.getResultValue(
portal_type="Software Instance", source_reference='children_b',
root_uid=software_instance_uid)
movement = children_software_instance.getAggregateRelatedValue(
portal_type="Sale Packing List Line")
children_partition = movement.getAggregateValue(
portal_type="Computer Partition")
slap_computer_partition = self.slap.registerComputerPartition(
computer_guid,
children_partition.getReference())
slap_computer_partition.request(
software_release=software_release_uri,
software_type=requested_reference,
partition_reference=requested_reference,
partition_parameter_kw=requested_parameter_dict)
def stepRequestSoftwareInstanceStartCheckSerializeIsCalled(self, sequence):
# check that on being_requested serialise is being called
# code stolen from testERP5Security:test_MultiplePersonReferenceConcurrentTransaction
class DummyTestException(Exception):
pass
def verify_serialize_call(self):
# it is checking that anything below computer_module raises exception
# thanks to this this test do not have to be destructive
if self.getPortalType() == "Software Instance":
raise DummyTestException
else:
return self.serialize_call()
from Products.ERP5Type.Base import Base
Base.serialize_call = Base.serialize
Base.serialize = verify_serialize_call
try:
self.assertRaises(DummyTestException,
self.portal.portal_catalog.getResultValue(
uid=sequence['software_instance_uid']).requestStartComputerPartition)
finally:
Base.serialize = Base.serialize_call
def stepRequestSoftwareInstanceDestroyCheckSerializeIsCalled(self, sequence):
# check that on being_requested serialise is being called
# code stolen from testERP5Security:test_MultiplePersonReferenceConcurrentTransaction
class DummyTestException(Exception):
pass
def verify_serialize_call(self):
# it is checking that anything below computer_module raises exception
# thanks to this this test do not have to be destructive
if self.getPortalType() == "Software Instance":
raise DummyTestException
else:
return self.serialize_call()
from Products.ERP5Type.Base import Base
Base.serialize_call = Base.serialize
Base.serialize = verify_serialize_call
instance = self.portal.portal_catalog.getResultValue(
uid=sequence['software_instance_uid'])
if instance.getPortalType() == "Software Instance":
shared = False
elif instance.getPortalType() == "Slave Instance":
shared = True
else:
raise NotImplementedError
try:
self.assertRaises(DummyTestException,instance.requestDestroy,
software_release=instance.getRootSoftwareReleaseUrl(),
instance_xml=instance.getTextContent(),
software_type=instance.getSourceReference(),
sla_xml=instance.getSlaXml(),
shared=shared,
)
finally:
Base.serialize = Base.serialize_call
def stepConfirmSaleOrderOrderedToCheckSerializeCalledOnSelected( def stepConfirmSaleOrderOrderedToCheckSerializeCalledOnSelected(
self, sequence, **kw): self, sequence, **kw):
...@@ -2222,17 +1932,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2222,17 +1932,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
computer = self.slap.registerComputer(computer_guid) computer = self.slap.registerComputer(computer_guid)
self.assertRaises(slap.Unauthorized, computer.getSoftwareReleaseList) self.assertRaises(slap.Unauthorized, computer.getSoftwareReleaseList)
def stepCheckNotFoundComputerGetSoftwareReleaseListCall(self, sequence, **kw):
"""
Check that Computer.getSoftwareReleaseList raise NotFoundError is the
computer doesn't exist.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
self.assertRaises(slap.NotFoundError, computer.getSoftwareReleaseList)
def stepCheckEmptyComputerGetSoftwareReleaseListCall(self, sequence, **kw): def stepCheckEmptyComputerGetSoftwareReleaseListCall(self, sequence, **kw):
""" """
Check that Computer.getSoftwareReleaseList returns an empty list. Check that Computer.getSoftwareReleaseList returns an empty list.
...@@ -2283,19 +1982,7 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2283,19 +1982,7 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertRaises(slap.NotFoundError, software_release.building) self.assertRaises(slap.NotFoundError, software_release.building)
def stepCheckSuccessSoftwareReleaseBuildingCall(self, sequence, **kw): def stepCheckNotFoundSoftwareReleaseDestroyedCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.building works.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
software_release.building()
def stepCheckNotFoundSoftwareReleaseBuildingCall(self, sequence, **kw):
computer_guid = sequence["computer_reference"] computer_guid = sequence["computer_reference"]
self.slap = slap.slap() self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None) self.slap.initializeConnection(self.server_url, timeout=None)
...@@ -2303,314 +1990,57 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2303,314 +1990,57 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
sequence['software_release_uri']) sequence['software_release_uri'])
# Note: Hackish # Note: Hackish
software_release._computer_guid = computer_guid software_release._computer_guid = computer_guid
self.assertRaises(slap.NotFoundError, software_release.building) self.assertRaises(slap.NotFoundError, software_release.destroyed)
def stepCheckTicAndNotFoundSoftwareReleaseBuildingCall(self, sequence, **kw): def stepCheckNotFoundSoftwareReleaseDestroyedAfterRegisterCall(self, sequence,
""" **kw):
Check that calling SoftwareRelease.building raises NotFoundError url = sequence["software_release_uri"]
after using tic.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap() self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None) self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid) software_release = self.slap.registerSoftwareRelease(url)
software_release = computer.getSoftwareReleaseList()[0]
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, software_release.building) self.assertRaises(slap.NotFoundError, software_release.destroyed)
def stepCheckNotFoundSoftwareReleaseAvailableCall(self, sequence, **kw): def stepCheckNotFoundSoftwareReleaseAvailableAfterRegisterCall(self, sequence,
**kw):
""" """
Check that calling SoftwareRelease.available raises NotFound Check that calling SoftwareRelease.available after just registration raises a
after using tic. NotFoundError
""" """
computer_guid = sequence["computer_reference"] url = sequence["software_release_uri"]
self.slap = slap.slap() self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None) self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease( software_release = self.slap.registerSoftwareRelease(url)
sequence['software_release_uri'])
# Note: Hackish
software_release._computer_guid = computer_guid
self.assertRaises(slap.NotFoundError, software_release.available) self.assertRaises(slap.NotFoundError, software_release.available)
def stepCheckNotFoundSoftwareReleaseDestroyedCall(self, sequence, **kw): def stepCheckNotFoundSoftwareReleaseErrorAfterRegisterCall(self, sequence,
computer_guid = sequence["computer_reference"] **kw):
"""
Check that calling SoftwareRelease.error after just registration raises a
NotFoundError
"""
url = sequence["software_release_uri"]
self.slap = slap.slap() self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None) self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease( software_release = self.slap.registerSoftwareRelease(url)
sequence['software_release_uri'])
# Note: Hackish self.assertRaises(slap.NotFoundError, software_release.error, "ErrorLog")
software_release._computer_guid = computer_guid
self.assertRaises(slap.NotFoundError, software_release.destroyed)
def stepCheckTicAndNotFoundSoftwareReleaseAvailableCall(self, sequence, **kw): def stepCheckNotFoundComputerPartitionBuildingAfterRegisterCall(self, sequence,
**kw):
""" """
Check that calling SoftwareRelease.available raises NotFound Check that calling ComputerPartition.building after just registrationraises a
after using tic. NotFoundError
""" """
computer_guid = sequence["computer_reference"] computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference_list"][0]
self.slap = slap.slap() self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None) self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid) computer_partition = self.slap.registerComputerPartition(
software_release = computer.getSoftwareReleaseList()[0] computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, software_release.available) self.assertRaises(slap.NotFoundError, computer_partition.building)
def stepCheckSoftwareReleaseErrorCall(self, sequence, **kw):
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease(
sequence['software_release_uri'])
# Note: Hackish
software_release._computer_guid = computer_guid
software_release.error("ErrorLog")
def stepCheckTicAndSoftwareReleaseErrorCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.error raises NotFound
after using tic.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
self.tic()
transaction.commit()
software_release.error("ErrorLog")
def stepCheckTicAndNotFoundSoftwareReleaseErrorCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.error raises NotFound
after using tic.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, software_release.error, "ErrorLog")
def stepCheckNotFoundSoftwareReleaseDestroyedAfterRegisterCall(self, sequence,
**kw):
url = sequence["software_release_uri"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease(url)
self.assertRaises(slap.NotFoundError, software_release.destroyed)
def stepCheckNotFoundSoftwareReleaseAvailableAfterRegisterCall(self, sequence,
**kw):
"""
Check that calling SoftwareRelease.available after just registration raises a
NotFoundError
"""
url = sequence["software_release_uri"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease(url)
self.assertRaises(slap.NotFoundError, software_release.available)
def stepCheckSuccessSoftwareReleaseAvailableCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.available works.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
software_release.available()
def stepCheckSuccessSoftwareReleaseDestroyedCall(self, sequence, **kw):
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
software_release.destroyed()
def stepCheckUnauthorizedSoftwareReleaseAvailableCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.available is Unauthorized
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
self.assertRaises(slap.Unauthorized, software_release.available)
def stepCheckNotFoundSoftwareReleaseErrorAfterRegisterCall(self, sequence,
**kw):
"""
Check that calling SoftwareRelease.error after just registration raises a
NotFoundError
"""
url = sequence["software_release_uri"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
software_release = self.slap.registerSoftwareRelease(url)
self.assertRaises(slap.NotFoundError, software_release.error, "ErrorLog")
def stepCheckSuccessSoftwareReleaseErrorCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.error works.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
software_release.error("ErrorLog")
def stepCheckUnauthorizedSoftwareReleaseBuildingCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.building raises an Unauthorized error
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
self.assertRaises(slap.Unauthorized, software_release.building)
def stepCheckTicAndSuccessSoftwareReleaseErrorCall(self, sequence, **kw):
"""
Check that calling SoftwareRelease.building is OK
after using tic.
"""
computer_guid = sequence["computer_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer = self.slap.registerComputer(computer_guid)
software_release = computer.getSoftwareReleaseList()[0]
self.tic()
transaction.commit()
software_release.error("ErrorLog")
def stepCheckSuccessComputerPartitionBuildingCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.building works
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
computer_partition.building()
def stepCheckNotFoundComputerPartitionBuildingCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.building after just registration raises a
NotFound
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.building)
def stepCheckUnauthorizedComputerPartitionBuildingCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.building after just registration raises a
Unauthorized
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.Unauthorized, computer_partition.building)
def stepCheckNotFoundComputerPartitionBuildingAfterRegisterCall(self, sequence,
**kw):
"""
Check that calling ComputerPartition.building after just registrationraises a
NotFoundError
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference_list"][0]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.building)
def stepAssertConfirmSalePackingListRaisesUnsupportedWorkflowMethod(self,
sequence, **kw):
"""
Confirm the sale packing list
"""
order = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertRaises(UnsupportedWorkflowMethod,
order.portal_workflow.doActionFor, order, 'confirm_action')
def stepCheckTicAndNotFoundComputerPartitionAvailableCall(self, sequence,
**kw):
"""
Check that calling ComputerPartition.building raises a NotFoundError
after using tic.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, computer_partition.available)
def stepCheckTicAndNotFoundComputerPartitionBuildingCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.building raises a NotFoundError
after using tic.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, computer_partition.building)
def stepCheckNotFoundComputerPartitionAvailableAfterRegisterCall(self, def stepCheckNotFoundComputerPartitionAvailableAfterRegisterCall(self,
sequence, **kw): sequence, **kw):
...@@ -2627,32 +2057,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2627,32 +2057,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertRaises(slap.NotFoundError, computer_partition.available) self.assertRaises(slap.NotFoundError, computer_partition.available)
def stepCheckUnauthorizedComputerPartitionAvailableCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.available raises an Unauthorized error
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.Unauthorized, computer_partition.available)
def stepCheckNotFoundComputerPartitionAvailableCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.available raises a NotFoundError
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.available)
def stepCheckSuccessComputerPartitionDestroyedCall(self, sequence, **kw): def stepCheckSuccessComputerPartitionDestroyedCall(self, sequence, **kw):
""" """
Check that calling ComputerPartition.available raises an Unauthorized error Check that calling ComputerPartition.available raises an Unauthorized error
...@@ -2678,37 +2082,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2678,37 +2082,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
computer_guid, partition_id) computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.destroyed) self.assertRaises(slap.NotFoundError, computer_partition.destroyed)
def stepCheckSuccessComputerPartitionAvailableCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.available raises an Unauthorized error
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
computer_partition.available()
def stepCheckTicAndUnauthorizedComputerPartitionAvailableCall(self, sequence,
**kw):
"""
Check that calling ComputerPartition.available raises an Unauthorized error
after using tic.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.Unauthorized, computer_partition.available)
def stepCheckNotFoundComputerPartitionErrorAfterRegisterCall(self, sequence, def stepCheckNotFoundComputerPartitionErrorAfterRegisterCall(self, sequence,
**kw): **kw):
""" """
...@@ -2722,18 +2095,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2722,18 +2095,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.slap.registerComputerPartition( self.slap.registerComputerPartition(
computer_guid, partition_id) computer_guid, partition_id)
def stepCheckNotFoundComputerPartitionErrorCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.error works.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.error, "ErrorLog")
def stepCheckSuccessComputerPartitionErrorCall(self, sequence, **kw): def stepCheckSuccessComputerPartitionErrorCall(self, sequence, **kw):
""" """
Check that calling ComputerPartition.error works. Check that calling ComputerPartition.error works.
...@@ -2777,62 +2138,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2777,62 +2138,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
uid=sequence["sale_packing_list_uid"]) uid=sequence["sale_packing_list_uid"])
self.assertFalse(packing_list.getComment('').endswith("ErrorLog")) self.assertFalse(packing_list.getComment('').endswith("ErrorLog"))
def stepCheckCancelledSalePackingList(self, sequence, **kw):
"""
Check that the sale packing list is cancelled
"""
packing_list = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertEquals("cancelled", packing_list.getSimulationState())
def stepCheckConfirmedSalePackingList(self, sequence, **kw):
"""
Check that the sale packing list is confirmed
"""
packing_list = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertEquals("confirmed", packing_list.getSimulationState())
def stepCheckStartedSalePackingList(self, sequence, **kw):
"""
Check that the sale packing list is started
"""
packing_list = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertEquals("started", packing_list.getSimulationState())
def stepCheckStoppedSalePackingList(self, sequence, **kw):
"""
Check that the sale packing list is stopped
"""
packing_list = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertEquals("stopped", packing_list.getSimulationState())
def stepCheckDeliveredSalePackingList(self, sequence, **kw):
"""
Check that the sale packing list is delivered
"""
packing_list = self.portal.portal_catalog.getResultValue(
uid=sequence["sale_packing_list_uid"])
self.assertEquals("delivered", packing_list.getSimulationState())
def stepCheckTicAndSuccessComputerPartitionErrorCall(self, sequence, **kw):
"""
Check that calling ComputerPartition.error works.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
computer_partition.error("ErrorLog")
def stepCheckNotFoundComputerPartitionGetSoftwareReleaseAfterRegisterCall( def stepCheckNotFoundComputerPartitionGetSoftwareReleaseAfterRegisterCall(
self, sequence, **kw): self, sequence, **kw):
""" """
...@@ -2865,38 +2170,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2865,38 +2170,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertTrue(isinstance(software_release, slap.SoftwareRelease)) self.assertTrue(isinstance(software_release, slap.SoftwareRelease))
self.assertEquals(url, software_release.getURI()) self.assertEquals(url, software_release.getURI())
def stepCheckNotFoundComputerPartitionGetSoftwareReleaseCall(self, sequence,
**kw):
"""
Check that calling ComputerPartition.getSoftwareRelease raise NotFoundError
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.getSoftwareRelease)
def stepCheckTicAndNotFoundComputerPartitionGetSoftwareReleaseCall(self,
sequence, **kw):
"""
Check that calling ComputerPartition.getSoftwareRelease raises an
NotFoundError after using tic.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.NotFoundError, computer_partition.getSoftwareRelease)
def stepCheckSuccessComputerPartitionGetInstanceParameterDictCall(self, def stepCheckSuccessComputerPartitionGetInstanceParameterDictCall(self,
sequence, **kw): sequence, **kw):
""" """
...@@ -2949,26 +2222,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2949,26 +2222,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
} }
self.assertSameDict(expected, result) self.assertSameDict(expected, result)
def stepSetSoftwareInstanceValidTestParameterXML(self, sequence, **kw):
"""
Set valid XML on the software instance
"""
software_instance_uid = sequence["software_instance_uid"]
software_instance = self.portal.portal_catalog.getResultValue(
uid=software_instance_uid)
test_parameter_id = 'test_parameter_id'
test_parameter_value = 'test_parameter_value'
software_instance.edit(text_content="""<?xml version="1.0" encoding="utf-8"?>
<instance>
<parameter id="%s">%s</parameter>
</instance>""" % (test_parameter_id, test_parameter_value))
sequence.edit(
test_parameter_id=test_parameter_id,
test_parameter_value=test_parameter_value
)
def stepSetSoftwareInstanceValidXML(self, sequence, **kw): def stepSetSoftwareInstanceValidXML(self, sequence, **kw):
""" """
Set valid XML on the software instance Set valid XML on the software instance
...@@ -2998,16 +2251,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -2998,16 +2251,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertRaises(slap.NotFoundError, self.assertRaises(slap.NotFoundError,
requested_slap_computer_partition.getInstanceParameterDict) requested_slap_computer_partition.getInstanceParameterDict)
def stepCheckRequestedComputerPartitionTestParameter(self, sequence, **kw):
requested_slap_computer_partition = sequence['requested_slap_computer_partition']
instance_parameter_dict = requested_slap_computer_partition\
.getInstanceParameterDict()
test_parameter_id = sequence['test_parameter_id']
test_parameter_value = sequence['test_parameter_value']
self.assertTrue(test_parameter_id in instance_parameter_dict)
self.assertEqual(test_parameter_value, instance_parameter_dict[
test_parameter_id])
def stepCheckRequestedComputerPartitionRequestedParameter(self, sequence, def stepCheckRequestedComputerPartitionRequestedParameter(self, sequence,
**kw): **kw):
requested_slap_computer_partition = sequence['requested_slap_computer_partition'] requested_slap_computer_partition = sequence['requested_slap_computer_partition']
...@@ -3051,19 +2294,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -3051,19 +2294,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
} }
self.assertSameDict(expected, result) self.assertSameDict(expected, result)
def stepCheckNotFoundComputerPartitionGetStateCall(self, sequence, **kw):
"""
Check that ComputerPartition.getState raises a NotFound error
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.assertRaises(slap.NotFoundError, computer_partition.getState)
def stepCheckStoppedComputerPartitionGetStateCall(self, sequence, **kw): def stepCheckStoppedComputerPartitionGetStateCall(self, sequence, **kw):
""" """
Check that ComputerPartition.getState return 'stopped' Check that ComputerPartition.getState return 'stopped'
...@@ -3104,25 +2334,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -3104,25 +2334,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
self.assertEquals('destroyed', computer_partition.getState()) self.assertEquals('destroyed', computer_partition.getState())
def stepCheckTicAndUnauthorizedComputerPartitionGetStateCall(self, sequence,
**kw):
"""
Check that calling ComputerPartition.getState raises an
Unauthorized error after using tic.
"""
computer_guid = sequence["computer_reference"]
partition_id = sequence["computer_partition_reference"]
self.slap = slap.slap()
self.slap.initializeConnection(self.server_url, timeout=None)
computer_partition = self.slap.registerComputerPartition(
computer_guid, partition_id)
self.tic()
transaction.commit()
self.assertRaises(slap.Unauthorized,
computer_partition.getState)
def stepCheckComputerPartitionIsFree(self, sequence, **kw): def stepCheckComputerPartitionIsFree(self, sequence, **kw):
computer_partition_uid = sequence["computer_partition_uid"] computer_partition_uid = sequence["computer_partition_uid"]
computer_partition = self.portal.portal_catalog.getResultValue( computer_partition = self.portal.portal_catalog.getResultValue(
...@@ -3669,9 +2880,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin): ...@@ -3669,9 +2880,6 @@ class TestVifibSlapWebServiceMixin(testVifibMixin):
def stepSetDeliveryLineAmountEqualTwo(self, sequence): def stepSetDeliveryLineAmountEqualTwo(self, sequence):
sequence.edit(delivery_line_amount=2) sequence.edit(delivery_line_amount=2)
def stepSetDeliveryLineAmountEqualThree(self, sequence):
sequence.edit(delivery_line_amount=3)
def stepSetDeliveryLineAmountEqualOne(self, sequence): def stepSetDeliveryLineAmountEqualOne(self, sequence):
sequence.edit(delivery_line_amount=1) sequence.edit(delivery_line_amount=1)
......
...@@ -478,30 +478,6 @@ class TestVifibSlapWebServiceSlaveInstance(TestVifibSlapWebServiceMixin): ...@@ -478,30 +478,6 @@ class TestVifibSlapWebServiceSlaveInstance(TestVifibSlapWebServiceMixin):
sequence_list.addSequenceString(sequence_string) sequence_list.addSequenceString(sequence_string)
sequence_list.play(self) sequence_list.play(self)
def stepStoreCurrentSoftwareInstanceBufferA(self, sequence, **kw):
sequence.edit(
software_instance_uid_buffer_a=sequence['software_instance_uid'],
software_instance_reference_buffer_a=sequence[
'software_instance_reference'])
def stepStoreCurrentSoftwareInstanceBufferB(self, sequence, **kw):
sequence.edit(
software_instance_uid_buffer_b=sequence['software_instance_uid'],
software_instance_reference_buffer_b=sequence[
'software_instance_reference'])
def stepRestoreCurrentSoftwareInstanceBufferA(self, sequence, **kw):
sequence.edit(
software_instance_uid=sequence['software_instance_uid_buffer_a'],
software_instance_reference=sequence[
'software_instance_reference_buffer_a'])
def stepRestoreCurrentSoftwareInstanceBufferB(self, sequence, **kw):
sequence.edit(
software_instance_uid=sequence['software_instance_uid_buffer_b'],
software_instance_reference=sequence[
'software_instance_reference_buffer_b'])
def test_SlaveInstance_request_stop(self): def test_SlaveInstance_request_stop(self):
""" """
Check that the Slave Instance will be stopped correctly Check that the Slave Instance will be stopped correctly
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment