Commit 651e64ab authored by Rafael Monnerat's avatar Rafael Monnerat

slapos_pdm: Reorganise tests for reduce code duplication and for speed up tests

Define smaler Unit Tests files is preferrable to make distribution easier for the test nodes.
parent 084e931f
...@@ -3,11 +3,27 @@ ...@@ -3,11 +3,27 @@
# #
# Copyright (c) 2019 Nexedi SA and Contributors. All Rights Reserved. # Copyright (c) 2019 Nexedi SA and Contributors. All Rights Reserved.
# #
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
############################################################################## ##############################################################################
from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin from erp5.component.test.testSlapOSPDMSkins import TestSlapOSPDMMixinSkins
from DateTime import DateTime from DateTime import DateTime
class TestSlapOSPDMUpgradeDecisionSkins(SlapOSTestCaseMixin): import transaction
class TestSlapOSPDMCreateUpgradeDecisionSkins(TestSlapOSPDMMixinSkins):
def _makeSoftwareProductCatalog(self): def _makeSoftwareProductCatalog(self):
self.software_product = self._makeSoftwareProduct(self.generateNewId()) self.software_product = self._makeSoftwareProduct(self.generateNewId())
self.previous_software_release = self._makeSoftwareRelease(self.generateNewId()) self.previous_software_release = self._makeSoftwareRelease(self.generateNewId())
...@@ -77,7 +93,7 @@ class TestSlapOSPDMUpgradeDecisionSkins(SlapOSTestCaseMixin): ...@@ -77,7 +93,7 @@ class TestSlapOSPDMUpgradeDecisionSkins(SlapOSTestCaseMixin):
self.tic() self.tic()
def afterSetUp(self): def afterSetUp(self):
SlapOSTestCaseMixin.afterSetUp(self) TestSlapOSPDMMixinSkins.afterSetUp(self)
preference = self.portal.portal_preferences.getActiveSystemPreference() preference = self.portal.portal_preferences.getActiveSystemPreference()
preference.setPreferredCloudContractEnabled(True) preference.setPreferredCloudContractEnabled(True)
self.tic() self.tic()
...@@ -145,3 +161,259 @@ class TestSlapOSPDMUpgradeDecisionSkins(SlapOSTestCaseMixin): ...@@ -145,3 +161,259 @@ class TestSlapOSPDMUpgradeDecisionSkins(SlapOSTestCaseMixin):
self.assertEqual(None, upgrade_decision) self.assertEqual(None, upgrade_decision)
shared_upgrade_decision = self.shared_hosting_subscription.HostingSubscription_createUpgradeDecision() shared_upgrade_decision = self.shared_hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(None, shared_upgrade_decision) self.assertEqual(None, shared_upgrade_decision)
def testHostingSubscription_createUpgradeDecision_no_newer(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
self.tic()
# Create Hosting Subscription
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self.tic()
upgrade_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(upgrade_decision, None)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
self._requestSoftwareRelease(software_product.getRelativeUrl())
self.tic()
upgrade_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(upgrade_decision, None)
def testHostingSubscription_createUpgradeDecision_closed_computer(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person, allocation_scope="close/outdated")
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision_create_once_transaction(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person, allocation_scope="open/personal")
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertNotEqual(up_decision, None)
self.assertEqual(up_decision.getSimulationState(), 'planned')
transaction.commit()
# call a second time without tic
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
# no new Upgrade decision created
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertNotEqual(up_decision, None)
self.assertEqual(up_decision.getSimulationState(), 'planned')
self.assertEqual(up_decision.UpgradeDecision_getHostingSubscription().\
getReference(), hosting_subscription.getReference())
self.assertEqual(up_decision.UpgradeDecision_getSoftwareRelease().\
getUrlString(), software_release2.getUrlString())
self.tic()
up_decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision2, None)
def testHostingSubscription_createUpgradeDecision_with_exist(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Install the another software release
software_release3 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release3.getUrlString())
self.tic()
up_decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision2.getSimulationState(), 'planned')
self.assertEqual(up_decision.getSimulationState(), 'cancelled')
release = up_decision2.UpgradeDecision_getSoftwareRelease()
self.assertEqual(release.getUrlString(),
software_release3.getUrlString())
def testHostingSubscription_createUpgradeDecision_rejected(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Reject upgrade decision
up_decision.reject()
self.tic()
in_progress = software_release2.SoftwareRelease_getUpgradeDecisionInProgress(
hosting_subscription.getUid())
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
# There is an upgrade decision in progress
self.assertNotEqual(in_progress, None)
# No new upgrade decision created with software_release2
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision_rejected_2(self):
person = self._makePerson()
computer, _ = self._makeComputer(owner=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Reject upgrade decision
up_decision.reject()
self.tic()
# Install the another software release
software_release3 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release3.getUrlString())
self.tic()
decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(decision2.getSimulationState(), 'planned')
self.assertEqual(up_decision.getSimulationState(), 'rejected')
release = decision2.UpgradeDecision_getSoftwareRelease()
self.assertEqual(release.getUrlString(),
software_release3.getUrlString())
\ No newline at end of file
...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
</item> </item>
<item> <item>
<key> <string>default_reference</string> </key> <key> <string>default_reference</string> </key>
<value> <string>testSlapOSPDMUpgradeDecisionSkins</string> </value> <value> <string>testSlapOSPDMCreateUpgradeDecisionSkins</string> </value>
</item> </item>
<item> <item>
<key> <string>description</string> </key> <key> <string>description</string> </key>
...@@ -24,7 +24,7 @@ ...@@ -24,7 +24,7 @@
</item> </item>
<item> <item>
<key> <string>id</string> </key> <key> <string>id</string> </key>
<value> <string>test.erp5.testSlapOSPDMUpgradeDecisionSkins</string> </value> <value> <string>test.erp5.testSlapOSPDMCreateUpgradeDecisionSkins</string> </value>
</item> </item>
<item> <item>
<key> <string>portal_type</string> </key> <key> <string>portal_type</string> </key>
......
...@@ -3,13 +3,6 @@ ...@@ -3,13 +3,6 @@
# #
# Copyright (c) 2002-2013 Nexedi SA and Contributors. All Rights Reserved. # Copyright (c) 2002-2013 Nexedi SA and Contributors. All Rights Reserved.
# #
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsibility of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# guarantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or # This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License # modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2 # as published by the Free Software Foundation; either version 2
...@@ -26,12 +19,10 @@ ...@@ -26,12 +19,10 @@
# #
############################################################################## ##############################################################################
import transaction
from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin, simulate from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin, simulate
from DateTime import DateTime from DateTime import DateTime
class TestSlapOSPDMMixinSkins(SlapOSTestCaseMixin):
class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def afterSetUp(self): def afterSetUp(self):
SlapOSTestCaseMixin.afterSetUp(self) SlapOSTestCaseMixin.afterSetUp(self)
self.new_id = self.generateNewId() self.new_id = self.generateNewId()
...@@ -44,31 +35,10 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -44,31 +35,10 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
state="started" state="started"
) )
def beforeTearDown(self):
id_list = []
for upgrade_decision in self.portal.portal_catalog(
portal_type="Upgrade Decision", reference="UD-TEST%"):
id_list.append(upgrade_decision.getId())
self.portal.upgrade_decision_module.manage_delObjects(id_list)
self.tic()
def _makePerson(self): def _makePerson(self):
person_user = self.makePerson(new_id=self.new_id) person_user = self.makePerson(new_id=self.new_id)
return person_user return person_user
def _makeComputer(self, allocation_scope='open/public'):
# Clone computer document
computer = self.portal.computer_module\
.template_computer.Base_createCloneDocument(batch_mode=1)
computer.edit(
title="computer start %s" % (self.new_id, ),
reference="TESTCOMPS-%s" % (self.new_id, )
)
computer.validate()
computer.edit(allocation_scope = allocation_scope)
return computer
def _makeComputerPartitions(self, computer): def _makeComputerPartitions(self, computer):
for i in range(1, 5): for i in range(1, 5):
id_ = 'partition%s' % (i, ) id_ = 'partition%s' % (i, )
...@@ -88,32 +58,6 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -88,32 +58,6 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
partition.markBusy() partition.markBusy()
break break
def _makeSoftwareProduct(self):
software_product = self.portal.software_product_module\
.template_software_product.Base_createCloneDocument(batch_mode=1)
new_id = self.generateNewId()
software_product.edit(
reference='TESTSOFTPROD-%s' % new_id,
title='Test software product %s' % new_id
)
software_product.validate()
software_product.publish()
return software_product
def _makeSoftwareRelease(self):
software_release = self.portal.software_release_module\
.template_software_release.Base_createCloneDocument(batch_mode=1)
new_id = self.generateNewId()
software_release.edit(
url_string=self.generateNewSoftwareReleaseUrl(),
reference='TESTSOFTRELS-%s' % new_id,
title='Start requested for %s' % new_id
)
software_release.release()
return software_release
def _requestSoftwareRelease(self, software_product_url, effective_date=None): def _requestSoftwareRelease(self, software_product_url, effective_date=None):
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
if not effective_date: if not effective_date:
...@@ -230,6 +174,17 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -230,6 +174,17 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
portal_type="Upgrade Decision Line", portal_type="Upgrade Decision Line",
title="TESTUPDE-%s" % self.new_id) title="TESTUPDE-%s" % self.new_id)
class TestSlapOSPDMSkins(TestSlapOSPDMMixinSkins):
def beforeTearDown(self):
id_list = []
for upgrade_decision in self.portal.portal_catalog(
portal_type="Upgrade Decision", reference="UD-TEST%"):
id_list.append(upgrade_decision.getId())
self.portal.upgrade_decision_module.manage_delObjects(id_list)
self.tic()
def test_getSortedSoftwareReleaseListFromSoftwareProduct(self): def test_getSortedSoftwareReleaseListFromSoftwareProduct(self):
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
release_list = software_product.SoftwareProduct_getSortedSoftwareReleaseList( release_list = software_product.SoftwareProduct_getSortedSoftwareReleaseList(
...@@ -295,8 +250,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -295,8 +250,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def test_HostingSubscription_getNewerSofwareRelease(self): def test_HostingSubscription_getNewerSofwareRelease(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person)
computer.edit(source_administration_value=person)
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id
newest_software_url = 'http://example.org/newest-%s.cfg' % self.new_id newest_software_url = 'http://example.org/newest-%s.cfg' % self.new_id
...@@ -321,8 +275,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -321,8 +275,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testHostingSubscription_getUpgradableSoftwareRelease_no_installation(self): def testHostingSubscription_getUpgradableSoftwareRelease_no_installation(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person)
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer) self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id
...@@ -347,8 +300,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -347,8 +300,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testHostingSubscription_getUpgradableSoftwareRelease(self): def testHostingSubscription_getUpgradableSoftwareRelease(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person)
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer) self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id oldest_software_url = 'http://example.org/oldest-%s.cfg' % self.new_id
...@@ -380,7 +332,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -380,7 +332,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testUpgradeDecision_getComputer(self): def testUpgradeDecision_getComputer(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -391,7 +343,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -391,7 +343,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
found_computer.getRelativeUrl()) found_computer.getRelativeUrl())
def testUpgradeDecision_getComputer_2_lines(self): def testUpgradeDecision_getComputer_2_lines(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -404,7 +356,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -404,7 +356,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
found_computer.getRelativeUrl()) found_computer.getRelativeUrl())
def testUpgradeDecision_getComputer_2_computer(self): def testUpgradeDecision_getComputer_2_computer(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -624,9 +576,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -624,9 +576,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testUpgradeDecision_upgradeComputer_no_software_release(self): def testUpgradeDecision_upgradeComputer_no_software_release(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person)
computer.edit(
source_administration_value = person.getRelativeUrl())
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -656,7 +606,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -656,7 +606,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testUpgradeDecision_upgradeComputer(self): def testUpgradeDecision_upgradeComputer(self):
self._makePerson() self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -683,7 +633,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -683,7 +633,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testUpgradeDecision_processUpgradeComputer(self): def testUpgradeDecision_processUpgradeComputer(self):
self._makePerson() self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -710,8 +660,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -710,8 +660,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testSoftwareRelease_createUpgradeDecision_computer(self): def testSoftwareRelease_createUpgradeDecision_computer(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person)
computer.edit(source_administration_value=person)
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
upgrade_decision = software_release.SoftwareRelease_createUpgradeDecision( upgrade_decision = software_release.SoftwareRelease_createUpgradeDecision(
...@@ -762,7 +711,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -762,7 +711,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testSoftwareRelease_getUpgradeDecisionInProgress(self): def testSoftwareRelease_getUpgradeDecisionInProgress(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl()) software_product.getRelativeUrl())
...@@ -788,7 +737,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -788,7 +737,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
self.assertEqual(in_progress, None) self.assertEqual(in_progress, None)
def testSoftwareRelease_getUpgradeDecisionInProgress_cancelled(self): def testSoftwareRelease_getUpgradeDecisionInProgress_cancelled(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl()) software_product.getRelativeUrl())
...@@ -815,7 +764,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -815,7 +764,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
self.assertEqual(in_progress.getReference(), upgrade_decision2.getReference()) self.assertEqual(in_progress.getReference(), upgrade_decision2.getReference())
def testSoftwareRelease_getUpgradeDecisionInProgress_rejected(self): def testSoftwareRelease_getUpgradeDecisionInProgress_rejected(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl()) software_product.getRelativeUrl())
...@@ -879,7 +828,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -879,7 +828,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testSoftwareRelease_getUpgradeDecisionInProgress_software_product(self): def testSoftwareRelease_getUpgradeDecisionInProgress_software_product(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl()) software_product.getRelativeUrl())
...@@ -942,7 +891,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -942,7 +891,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testUpgradeDecision_tryToCancel(self): def testUpgradeDecision_tryToCancel(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
software_release2 = self._makeSoftwareRelease() software_release2 = self._makeSoftwareRelease()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
...@@ -970,7 +919,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -970,7 +919,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
self.assertEqual(upgrade_decision2.getSimulationState(), 'started') self.assertEqual(upgrade_decision2.getSimulationState(), 'started')
def testUpgradeDecision_tryToCancel_withRejected(self): def testUpgradeDecision_tryToCancel_withRejected(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
software_release2 = self._makeSoftwareRelease() software_release2 = self._makeSoftwareRelease()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
...@@ -991,8 +940,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -991,8 +940,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testComputer_checkAndCreateUpgradeDecision(self): def testComputer_checkAndCreateUpgradeDecision(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person,
computer.edit(source_administration_value=person,
allocation_scope="open/public") allocation_scope="open/public")
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
...@@ -1026,8 +974,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -1026,8 +974,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testComputer_checkAndCreateUpgradeDecision_personal_with_exist(self): def testComputer_checkAndCreateUpgradeDecision_personal_with_exist(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer(allocation_scope="open/personal") computer, _ = self._makeComputer(owner=person, allocation_scope="open/personal")
computer.edit(source_administration_value=person)
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl()) software_product.getRelativeUrl())
...@@ -1054,8 +1001,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -1054,8 +1001,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
def testComputer_checkAndCreateUpgradeDecision_public_with_exist(self): def testComputer_checkAndCreateUpgradeDecision_public_with_exist(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer(owner=person,
computer.edit(source_administration_value=person,
allocation_scope="open/public") allocation_scope="open/public")
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease( software_release = self._requestSoftwareRelease(
...@@ -1076,267 +1022,6 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -1076,267 +1022,6 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
self.assertEqual(upgrade_decision.getSimulationState(), 'started') self.assertEqual(upgrade_decision.getSimulationState(), 'started')
def testHostingSubscription_createUpgradeDecision_no_newer(self):
person = self._makePerson()
computer = self._makeComputer()
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
self.tic()
# Create Hosting Subscription
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self.tic()
upgrade_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(upgrade_decision, None)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
self._requestSoftwareRelease(software_product.getRelativeUrl())
self.tic()
upgrade_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(upgrade_decision, None)
def testHostingSubscription_createUpgradeDecision_closed_computer(self):
person = self._makePerson()
computer = self._makeComputer(allocation_scope="close/outdated")
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision_create_once_transaction(self):
person = self._makePerson()
computer = self._makeComputer(allocation_scope="open/personal")
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertNotEqual(up_decision, None)
self.assertEqual(up_decision.getSimulationState(), 'planned')
transaction.commit()
# call a second time without tic
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
# no new Upgrade decision created
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision(self):
person = self._makePerson()
computer = self._makeComputer()
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer,
software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertNotEqual(up_decision, None)
self.assertEqual(up_decision.getSimulationState(), 'planned')
self.assertEqual(up_decision.UpgradeDecision_getHostingSubscription().\
getReference(), hosting_subscription.getReference())
self.assertEqual(up_decision.UpgradeDecision_getSoftwareRelease().\
getUrlString(), software_release2.getUrlString())
self.tic()
up_decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision2, None)
def testHostingSubscription_createUpgradeDecision_with_exist(self):
person = self._makePerson()
computer = self._makeComputer()
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation( computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Install the another software release
software_release3 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release3.getUrlString())
self.tic()
up_decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision2.getSimulationState(), 'planned')
self.assertEqual(up_decision.getSimulationState(), 'cancelled')
release = up_decision2.UpgradeDecision_getSoftwareRelease()
self.assertEqual(release.getUrlString(),
software_release3.getUrlString())
def testHostingSubscription_createUpgradeDecision_rejected(self):
person = self._makePerson()
computer = self._makeComputer()
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Reject upgrade decision
up_decision.reject()
self.tic()
in_progress = software_release2.SoftwareRelease_getUpgradeDecisionInProgress(
hosting_subscription.getUid())
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
# There is an upgrade decision in progress
self.assertNotEqual(in_progress, None)
# No new upgrade decision created with software_release2
self.assertEqual(up_decision, None)
def testHostingSubscription_createUpgradeDecision_rejected_2(self):
person = self._makePerson()
computer = self._makeComputer()
computer.edit(source_administration_value=person)
self._makeComputerPartitions(computer)
software_product = self._makeSoftwareProduct()
software_release = self._requestSoftwareRelease(
software_product.getRelativeUrl())
url_string = software_release.getUrlString()
self._makeSoftwareInstallation(computer, url_string)
# Create Hosting Subscription and Software Instance
hosting_subscription = self._makeFullHostingSubscription(
url_string, person)
self._makeFullSoftwareInstance(hosting_subscription, url_string)
self._markComputerPartitionBusy(computer,
hosting_subscription.getPredecessorValue())
# Install the Newest software release
software_release2 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release2.getUrlString())
self.tic()
up_decision = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(up_decision.getSimulationState(), 'planned')
# Reject upgrade decision
up_decision.reject()
self.tic()
# Install the another software release
software_release3 = self._requestSoftwareRelease(
software_product.getRelativeUrl())
self._makeSoftwareInstallation(computer, software_release3.getUrlString())
self.tic()
decision2 = hosting_subscription.HostingSubscription_createUpgradeDecision()
self.assertEqual(decision2.getSimulationState(), 'planned')
self.assertEqual(up_decision.getSimulationState(), 'rejected')
release = decision2.UpgradeDecision_getSoftwareRelease()
self.assertEqual(release.getUrlString(),
software_release3.getUrlString())
def testBase_acceptUpgradeDecision_no_reference(self): def testBase_acceptUpgradeDecision_no_reference(self):
self._makeUpgradeDecision() self._makeUpgradeDecision()
self.assertRaises(ValueError, self.portal.Base_acceptUpgradeDecision, None) self.assertRaises(ValueError, self.portal.Base_acceptUpgradeDecision, None)
...@@ -1547,7 +1232,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -1547,7 +1232,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
"%s contains the wrong message" % redirect_url) "%s contains the wrong message" % redirect_url)
def testUpgradeDecision_isUpgradeFinished_computer(self): def testUpgradeDecision_isUpgradeFinished_computer(self):
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
upgrade_decision = self._makeUpgradeDecision() upgrade_decision = self._makeUpgradeDecision()
upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision) upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
...@@ -1626,7 +1311,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin): ...@@ -1626,7 +1311,7 @@ class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
'context.REQUEST["testUpgradeDecision_notify_computer"])') 'context.REQUEST["testUpgradeDecision_notify_computer"])')
def testUpgradeDecision_notify_computer(self): def testUpgradeDecision_notify_computer(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release.setAggregateValue(software_product) software_release.setAggregateValue(software_product)
...@@ -1751,7 +1436,7 @@ ${new_software_release_url}""", ...@@ -1751,7 +1436,7 @@ ${new_software_release_url}""",
'', 'return 1') '', 'return 1')
def testUpgradeDecision_notifyDelivered_computer(self): def testUpgradeDecision_notifyDelivered_computer(self):
person = self._makePerson() person = self._makePerson()
computer = self._makeComputer() computer, _ = self._makeComputer()
software_release = self._makeSoftwareRelease() software_release = self._makeSoftwareRelease()
software_product = self._makeSoftwareProduct() software_product = self._makeSoftwareProduct()
software_release.setAggregateValue(software_product) software_release.setAggregateValue(software_product)
......
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