Improve upgrade decision creation

master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/Computer_checkAndCreateUpgradeDecision.xml

@@ -53,7 +53,7 @@
             <value> <string>computer = context\n
 portal = context.getPortalObject()\n
 \n
-full_software_release_list = [si.getUrlString() for si in \n
+full_software_release_list = [si.getUrlString() for si in\n
               portal.portal_catalog(\n
                 portal_type=\'Software Installation\',\n
                 default_aggregate_uid=computer.getUid(),\n
@@ -68,7 +68,7 @@ software_release_list = portal.portal_catalog(\n
                           url_string=full_software_release_list,\n
                           group_by=\'default_aggregate_uid\'\n
                         )\n
-\n
+upgrade_decision_list = []\n
 for software_release in software_release_list:\n
   software_product_reference = software_release.getAggregateReference()\n
   sorted_list = portal.SoftwareProduct_getSortedSoftwareReleaseList(\n
@@ -79,17 +79,28 @@ for software_release in software_release_list:\n
       sorted_list[0].getUrlString() not in full_software_release_list:\n
     \n
     newer_release = sorted_list[0]\n
-    title = \'A new software release is available for %s\' % \\\n
-                        software_product_reference\n
-    # Search if exist upgrade decision for this software product (by title)\n
-    is_decision_in_progress = newer_release.\\\n
-            SoftwareRelease_isUpgradeDecisionInProgress(title=title)\n
-    if is_decision_in_progress:\n
+    title = \'A new version of %s is available for %s\' % \\\n
+                        (software_product_reference, context.getTitle()) \n
+    # If exist upgrade decision in progress try to cancel it\n
+    decision_in_progress = newer_release.\\\n
+            SoftwareRelease_getUpgradeDecisionInProgress(computer.getUid())\n
+    if decision_in_progress and \\\n
+        not decision_in_progress.UpgradeDecision_tryToCancel(\n
+          newer_release.getUrlString()):\n
       continue\n
   \n
-    return newer_release.SoftwareRelease_createUpgradeDecision(\n
-        source_url=computer.getRelativeUrl(), title=title\n
-      )\n
+    upgrade_decision = newer_release.SoftwareRelease_createUpgradeDecision(\n
+        source_url=computer.getRelativeUrl(),\n
+        title=title)\n
+        \n
+    if context.getAllocationScope() in ["open/public", "open/friend"]:\n
+      upgrade_decision.start()\n
+    elif context.getAllocationScope() in ["open/personal"]:\n
+      upgrade_decision.plan()\n
+      \n
+    upgrade_decision_list.append(upgrade_decision)\n
+\n
+return upgrade_decision_list\n
 </string> </value>
         </item>
         <item>

master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/Computer_hostingSubscriptionCreateUpgradeDecision.xml

@@ -50,56 +50,51 @@
         </item>
         <item>
             <key> <string>_body</string> </key>
-            <value> <string>computer = context\n
-portal = context.getPortalObject()\n
+            <value> <string>portal = context.getPortalObject()\n
 \n
 partition_list = portal.portal_catalog(portal_type=\'Computer Partition\',\n
                                         free_for_request=0,\n
-                                        parent_uid=computer.getUid())\n
+                                        parent_uid=context.getUid())\n
+valid_slap_state = [\'start_requested\', \'stop_requested\']\n
 \n
-# Get Hosting Subscription for all allocated partition\n
 hosting_subscription_list = []\n
+upgrade_decision_list = []\n
 for partition in partition_list:\n
   software_instance = partition.getAggregateRelatedValue(\n
                             portal_type=\'Software Instance\')\n
-  if software_instance:\n
-    hs = software_instance.getSpecialiseValue(\n
-                  portal_type=\'Hosting Subscription\')\n
-    if hs and hs.getSlapState() in \\\n
-        [\'start_requested\', \'stop_requested\'] and \\\n
-        not hs in hosting_subscription_list:\n
-      hosting_subscription_list.append(hs)\n
-\n
-if len(hosting_subscription_list) == 0:\n
-  return\n
+  if not software_instance:\n
+    continue\n
 \n
-for hosting_subscription in hosting_subscription_list:\n
-  is_upgradable = hosting_subscription.HostingSubscription_isUpgradable()\n
-  if not is_upgradable:\n
+  hosting_subscription = software_instance.getSpecialiseValue(\n
+                portal_type=\'Hosting Subscription\')\n
+  if hosting_subscription and hosting_subscription.getSlapState() \\\n
+      in valid_slap_state and not \\\n
+      hosting_subscription in hosting_subscription_list:\n
+    hosting_subscription_list.append(hosting_subscription)\n
+  else:\n
     continue\n
   \n
-  newer_release_string = hosting_subscription.\\\n
-                    HostingSubscription_getNewerSofwareRelease()\n
-  if not newer_release_string:\n
+  newer_release = hosting_subscription.\\\n
+                    HostingSubscription_getUpgradableSoftwareRelease()\n
+  if newer_release is None:\n
     continue\n
   \n
-  software_release = portal.portal_catalog.getResultValue(\n
-                              portal_type=\'Software Release\',\n
-                              url_string=newer_release_string)\n
-  if not software_release:\n
-    continue\n
+  decision_in_progress = newer_release.\\\n
+      SoftwareRelease_getUpgradeDecisionInProgress(hosting_subscription.getUid())\n
   \n
-  title = \'A new software release is available for %s\' % \\\n
-                        hosting_subscription.getReference()\n
-  # Search if exist upgrade decision for this Hosting Subscription (by title)\n
-  is_decision_in_progress = software_release.\\\n
-          SoftwareRelease_isUpgradeDecisionInProgress(title=title)\n
-  if is_decision_in_progress:\n
+  if decision_in_progress and \\\n
+      not decision_in_progress.UpgradeDecision_tryToCancel(\n
+        newer_release.getUrlString()):\n
     continue\n
-\n
-  return software_release.SoftwareRelease_createUpgradeDecision(\n
-      source_url=hosting_subscription.getRelativeUrl(), title=title\n
+  \n
+  upgrade_decision = newer_release.SoftwareRelease_createUpgradeDecision(\n
+    source_url=hosting_subscription.getRelativeUrl(),\n
+    title=\'A new upgrade is available for %s\' % hosting_subscription.getTitle()\n
   )\n
+  upgrade_decision.plan()\n
+  upgrade_decision_list.append(upgrade_decision)\n
+\n
+return upgrade_decision_list\n
 </string> </value>
         </item>
         <item>

master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/SoftwareRelease_createUpgradeDecision.xml

@@ -55,8 +55,8 @@
 from DateTime import DateTime\n
 \n
 portal = context.getPortalObject()\n
-\n
 software_release = context\n
+\n
 source_product = portal.restrictedTraverse(source_url, None)\n
 if not source_product:\n
   return\n
@@ -73,14 +73,12 @@ if not person_url:\n
   return\n
 \n
 upgrade_decision = portal.upgrade_decision_module.\\\n
-            template_upgrade_decision.Base_createCloneDocument(batch_mode=1) \n
+            template_upgrade_decision.Base_createCloneDocument(batch_mode=1)\n
 upgrade_decision.edit(\n
         title=title,\n
         destination_section=person_url,\n
-        destination_decision=person_url,\n
-        start_date=DateTime()\n
+        destination_decision=person_url\n
 )\n
-upgrade_decision.confirm()\n
 decision_line_list = upgrade_decision.contentValues(\n
                     portal_type=\'Upgrade Decision Line\')\n
 if len(decision_line_list) > 0:\n

master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/SoftwareRelease_getUpgradeDecisionInProgress.xml

+<?xml version="1.0"?>
+<ZopeData>
+  <record id="1" aka="AAAAAAAAAAE=">
+    <pickle>
+      <global name="PythonScript" module="Products.PythonScripts.PythonScript"/>
+    </pickle>
+    <pickle>
+      <dictionary>
+        <item>
+            <key> <string>Script_magic</string> </key>
+            <value> <int>3</int> </value>
+        </item>
+        <item>
+            <key> <string>_bind_names</string> </key>
+            <value>
+              <object>
+                <klass>
+                  <global name="NameAssignments" module="Shared.DC.Scripts.Bindings"/>
+                </klass>
+                <tuple/>
+                <state>
+                  <dictionary>
+                    <item>
+                        <key> <string>_asgns</string> </key>
+                        <value>
+                          <dictionary>
+                            <item>
+                                <key> <string>name_container</string> </key>
+                                <value> <string>container</string> </value>
+                            </item>
+                            <item>
+                                <key> <string>name_context</string> </key>
+                                <value> <string>context</string> </value>
+                            </item>
+                            <item>
+                                <key> <string>name_m_self</string> </key>
+                                <value> <string>script</string> </value>
+                            </item>
+                            <item>
+                                <key> <string>name_subpath</string> </key>
+                                <value> <string>traverse_subpath</string> </value>
+                            </item>
+                          </dictionary>
+                        </value>
+                    </item>
+                  </dictionary>
+                </state>
+              </object>
+            </value>
+        </item>
+        <item>
+            <key> <string>_body</string> </key>
+            <value> <string encoding="cdata"><![CDATA[
+
+portal = context.getPortalObject()\n
+product_reference = context.getAggregateReference()\n
+\n
+decision_line_in_progress_list = portal.portal_catalog(\n
+                    portal_type=\'Upgrade Decision Line\',\n
+                    aggregate_uid=aggregate_uid)\n
+\n
+for decision_line in decision_line_in_progress_list:\n
+  upgrade_decision = decision_line.getParentValue()\n
+  if upgrade_decision.getSimulationState() not in [\'planned\',\n
+      \'confirmed\', \'started\', \'stopped\']:\n
+    continue\n
+  release_list = decision_line.getAggregateValueList(portal_type="Software Release")\n
+  if len(release_list) > 1:\n
+    continue\n
+  if not release_list[0]:\n
+    continue\n
+  # If both software release belong to the same software product, there is an upgrade decision in progress \n
+  if product_reference == release_list[0].getAggregateReference():\n
+    return upgrade_decision\n
+
+
+]]></string> </value>
+        </item>
+        <item>
+            <key> <string>_params</string> </key>
+            <value> <string>aggregate_uid</string> </value>
+        </item>
+        <item>
+            <key> <string>id</string> </key>
+            <value> <string>SoftwareRelease_getUpgradeDecisionInProgress</string> </value>
+        </item>
+      </dictionary>
+    </pickle>
+  </record>
+</ZopeData>

master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/SoftwareRelease_isUpgradeDecisionInProgress.xml → master/bt5/slapos_pdm/SkinTemplateItem/portal_skins/slapos_pdm/UpgradeDecision_tryToCancel.xml

@@ -50,39 +50,30 @@
         </item>
         <item>
             <key> <string>_body</string> </key>
-            <value> <string>url_string = context.getUrlString()\n
-portal = context.getPortalObject()\n
+            <value> <string>upgrade_decision = context\n
+cancel_state_list = [\'confirmed\', \'planned\']\n
 \n
-# Check if there is an upgrade decision in progress\n
-kw[\'portal_type\'] = \'Upgrade Decision\'\n
-upgrade_decision_in_progress = portal.portal_catalog(**kw)\n
-\n
-if len(upgrade_decision_in_progress) == 0:\n
+if upgrade_decision.getSimulationState() in cancel_state_list:\n
+  current_release = upgrade_decision.UpgradeDecision_getSoftwareRelease()\n
+  if not current_release:\n
+    # This upgrade decision is not valid\n
+    return False\n
+  if current_release.getUrlString() == new_url_string:\n
+    # Cannot cancel because the software releases are the same\n
+    return False\n
+  upgrade_decision.cancel()\n
+  return True\n
+else:\n
   return False\n
-\n
-in_progress = False\n
-for decision_in_progress in upgrade_decision_in_progress:\n
-  try:\n
-    software_release = decision_in_progress.\\\n
-              UpgradeDecision_getSoftwareRelease()\n
-  except ValueError:\n
-    continue\n
-  if not software_release:\n
-    continue\n
-  if url_string == software_release.getUrlString():\n
-    in_progress = True\n
-    break\n
-\n
-return in_progress\n
 </string> </value>
         </item>
         <item>
             <key> <string>_params</string> </key>
-            <value> <string>**kw</string> </value>
+            <value> <string>new_url_string</string> </value>
         </item>
         <item>
             <key> <string>id</string> </key>
-            <value> <string>SoftwareRelease_isUpgradeDecisionInProgress</string> </value>
+            <value> <string>UpgradeDecision_tryToCancel</string> </value>
         </item>
       </dictionary>
     </pickle>

master/bt5/slapos_pdm/TestTemplateItem/testSlapOSPDMSkins.py

@@ -593,7 +593,7 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
           title="TEST-SRUPDE-%s" % self.new_id)
     self.tic()
     
-    self.assertEqual(upgrade_decision.getSimulationState(), 'confirmed')
+    self.assertEqual(upgrade_decision.getSimulationState(), 'draft')
     self.assertEqual(upgrade_decision.getDestinationSection(),
                        person.getRelativeUrl())
     
@@ -622,7 +622,7 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
           title="TEST-SRUPDE-%s" % self.new_id)
     self.tic()
     
-    self.assertEqual(upgrade_decision.getSimulationState(), 'confirmed')
+    self.assertEqual(upgrade_decision.getSimulationState(), 'draft')
     self.assertEqual(upgrade_decision.getDestinationSection(),
                        person.getRelativeUrl())
     
@@ -635,35 +635,177 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
                       software_release.getRelativeUrl())
   
   
-  def testSoftwareRelease_isUpgradeDecisionInProgress(self):
+  def testSoftwareRelease_getUpgradeDecisionInProgress(self):
     computer = self._makeComputer(self.new_id)
-    software_release = self._makeSoftwareRelease(self.new_id)
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
     upgrade_decision = self._makeUpgradeDecision()
     upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
     upgrade_decision_line.setAggregateValueList([software_release, computer])
     software_release2 = self._makeSoftwareRelease(self.generateNewId())
     upgrade_decision.confirm()
+    reference = upgrade_decision.getReference()
     
     self.tic()
     
-    in_progress = software_release.SoftwareRelease_isUpgradeDecisionInProgress(
-                                title=upgrade_decision.getTitle()
-                              )
-    self.assertEqual(in_progress, True)
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
     
-    in_progress = software_release.SoftwareRelease_isUpgradeDecisionInProgress()
-    self.assertEqual(in_progress, True)
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                software_release.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
     
-    in_progress = software_release.SoftwareRelease_isUpgradeDecisionInProgress(
-                                title=upgrade_decision.getTitle(),
-                                simulation_state='stopped'
-                              )
-    self.assertEqual(in_progress, False)
+    in_progress = software_release2.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress, None)
   
-    in_progress = software_release2.SoftwareRelease_isUpgradeDecisionInProgress(
-                                title=upgrade_decision.getTitle()
-                              )
-    self.assertEqual(in_progress, False)
+  def testSoftwareRelease_getUpgradeDecisionInProgress_cancelled(self):
+    computer = self._makeComputer(self.new_id)
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    upgrade_decision = self._makeUpgradeDecision()
+    upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
+    upgrade_decision_line.setAggregateValueList([software_release, computer])
+    upgrade_decision.confirm()
+    upgrade_decision.cancel()
+    
+    self.tic()
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress, None)
+    
+    upgrade_decision2 = self._makeUpgradeDecision()
+    upgrade_decision_line2 = self._makeUpgradeDecisionLine(upgrade_decision2)
+    upgrade_decision_line2.setAggregateValueList([software_release, computer])
+    upgrade_decision2.confirm()
+    upgrade_decision2.start()
+    self.tic()
+    
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress.getReference(), upgrade_decision2.getReference())
+  
+  def testSoftwareRelease_getUpgradeDecisionInProgress_hosting_subs(self):
+    person = self._makePerson(self.new_id)
+    hosting_subscription = self._makeHostingSubscription(self.new_id)
+    hosting_subscription.edit(
+          destination_section_value = person.getRelativeUrl())
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    upgrade_decision = self._makeUpgradeDecision()
+    upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
+    upgrade_decision_line.setAggregateValueList([software_release,
+                                                      hosting_subscription])
+    upgrade_decision.confirm()
+    reference = upgrade_decision.getReference()
+    self.tic()
+    
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                hosting_subscription.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
+    
+    upgrade_decision.cancel()
+    self.tic()
+    
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                hosting_subscription.getUid())
+    self.assertEqual(in_progress, None)
+  
+  
+  def testSoftwareRelease_getUpgradeDecisionInProgress_software_product(self):
+    computer = self._makeComputer(self.new_id)
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    software_release2 = self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    software_release3 = self._makeSoftwareRelease(self.generateNewId())
+    upgrade_decision = self._makeUpgradeDecision()
+    upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
+    upgrade_decision_line.setAggregateValueList([software_release, computer])
+    upgrade_decision.confirm()
+    reference = upgrade_decision.getReference()
+    
+    self.tic()
+    
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
+    
+    in_progress = software_release2.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
+    
+    in_progress = software_release3.SoftwareRelease_getUpgradeDecisionInProgress(
+                                computer.getUid())
+    self.assertEqual(in_progress, None)
+  
+  
+  def testSoftwareRelease_getUpgradeDecisionInProgress_software_product_hs(self):
+    person = self._makePerson(self.new_id)
+    hosting_subscription = self._makeHostingSubscription(self.new_id)
+    hosting_subscription.edit(
+          destination_section_value = person.getRelativeUrl())
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    software_release2 = self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    software_release3 = self._makeSoftwareRelease(self.generateNewId())
+    upgrade_decision = self._makeUpgradeDecision()
+    upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
+    upgrade_decision_line.setAggregateValueList([software_release,
+                                                      hosting_subscription])
+    upgrade_decision.confirm()
+    reference = upgrade_decision.getReference()
+    reference = upgrade_decision.getReference()
+    
+    self.tic()
+    
+    in_progress = software_release.SoftwareRelease_getUpgradeDecisionInProgress(
+                                hosting_subscription.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
+    
+    in_progress = software_release2.SoftwareRelease_getUpgradeDecisionInProgress(
+                                hosting_subscription.getUid())
+    self.assertEqual(in_progress.getReference(), reference)
+    
+    in_progress = software_release3.SoftwareRelease_getUpgradeDecisionInProgress(
+                                hosting_subscription.getUid())
+    self.assertEqual(in_progress, None)
+  
+  
+  def testUpgradeDecision_tryToCancel(self):
+    computer = self._makeComputer(self.new_id)
+    software_release = self._makeSoftwareRelease(self.new_id)
+    software_release2 = self._makeSoftwareRelease(self.generateNewId())
+    upgrade_decision = self._makeUpgradeDecision()
+    upgrade_decision_line = self._makeUpgradeDecisionLine(upgrade_decision)
+    upgrade_decision_line.setAggregateValueList([software_release, computer])
+    upgrade_decision.confirm()
+    
+    upgrade_decision2 = self._makeUpgradeDecision()
+    upgrade_decision_line2 = self._makeUpgradeDecisionLine(upgrade_decision2)
+    upgrade_decision_line2.setAggregateValueList([software_release, computer])
+    upgrade_decision2.confirm()
+    upgrade_decision2.start()
+    
+    url = software_release.getUrlString()
+    url2 = software_release2.getUrlString()
+    
+    # Cancel is not possible with the same url_string
+    self.assertEqual(upgrade_decision.UpgradeDecision_tryToCancel(url), False)
+    self.assertEqual(upgrade_decision.UpgradeDecision_tryToCancel(url2), True)
+    self.assertEqual(upgrade_decision.getSimulationState(), 'cancelled')
+    
+    # Cancel is no longer possible
+    self.assertEqual(upgrade_decision2.UpgradeDecision_tryToCancel(url), False)
+    self.assertEqual(upgrade_decision2.UpgradeDecision_tryToCancel(url2), False)
+    self.assertEqual(upgrade_decision2.getSimulationState(), 'started')
     
     
   def testComputer_checkAndCreateUpgradeDecision(self):
@@ -676,9 +818,8 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     self._makeSoftwareInstallation(self.new_id,
                               computer, software_release.getUrlString())
     self.tic()
-    
     upgrade_decision = computer.Computer_checkAndCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision, None)
+    self.assertEqual(len(upgrade_decision), 0)
     
     software_release2 = self._requestSoftwareRelease(self.generateNewId(),
                                       software_product.getRelativeUrl())
@@ -689,20 +830,47 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     self.tic()
     
     upgrade_decision = computer.Computer_checkAndCreateUpgradeDecision()
+    self.assertEqual(len(upgrade_decision), 1)
+    self.assertEqual(upgrade_decision[0].getSimulationState(), 'confirmed')
     
-    self.assertEqual(upgrade_decision.getSimulationState(), 'confirmed')
-    
-    computer_aggregate = upgrade_decision.UpgradeDecision_getComputer()
+    computer_aggregate = upgrade_decision[0].UpgradeDecision_getComputer()
     self.assertEqual(computer_aggregate.getReference(),
                       computer.getReference())
-    url_string = upgrade_decision.UpgradeDecision_getSoftwareRelease()
-    self.assertEqual(url_string.getUrlString(),
+    release = upgrade_decision[0].UpgradeDecision_getSoftwareRelease()
+    self.assertEqual(release.getUrlString(),
                                 software_release2.getUrlString())
-    
     self.tic()
     upgrade_decision2 = computer.Computer_checkAndCreateUpgradeDecision()
+    self.assertEqual(len(upgrade_decision2), 0)
+  
+  def testComputer_checkAndCreateUpgradeDecision_with_exist(self):
+    person = self._makePerson(self.new_id)
+    computer = self._makeComputer(self.new_id)
+    computer.edit(source_administration_value=person)
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    self._makeSoftwareInstallation(self.new_id,
+                              computer, software_release.getUrlString())
+    self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    self.tic()
+    
+    upgrade_decision = computer.Computer_checkAndCreateUpgradeDecision()[0]
+    self.assertEqual(upgrade_decision.getSimulationState(), 'confirmed')
+    
+    software_release3 = self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    self.tic()
+    
+    upgrade_decision2 = computer.Computer_checkAndCreateUpgradeDecision()[0]
+    
+    self.assertEqual(upgrade_decision.getSimulationState(), 'cancelled')
+    self.assertEqual(upgrade_decision2.getSimulationState(), 'confirmed')
+    release = upgrade_decision2.UpgradeDecision_getSoftwareRelease()
+    self.assertEqual(release.getUrlString(),
+                                software_release3.getUrlString())
     
-    self.assertEqual(upgrade_decision2, None)
   
   def testComputer_hostingSubscriptionCreateUpgradeDecision_no_newer(self):
     person = self._makePerson(self.new_id)
@@ -717,7 +885,7 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     self.tic()
     
     upgrade_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision, None)
+    self.assertEqual(len(upgrade_decision), 0)
     
     # Create Hosting Subscription
     hosting_subscription = self._makeFullHostingSubscription(self.new_id,
@@ -725,7 +893,7 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     self.tic()
     
     upgrade_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision, None)
+    self.assertEqual(len(upgrade_decision), 0)
     
     self._makeFullSoftwareInstance(hosting_subscription, url_string)
     self._markComputerPartitionBusy(computer,
@@ -736,7 +904,7 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     self.tic()
     
     upgrade_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision, None)
+    self.assertEqual(len(upgrade_decision), 0)
   
   def testComputer_hostingSubscriptionCreateUpgradeDecision(self):
     person = self._makePerson(self.new_id)
@@ -760,22 +928,66 @@ class TestSlapOSPDMSkins(testSlapOSMixin):
     # Install the Newest software release
     software_release2 = self._requestSoftwareRelease(self.generateNewId(),
                                       software_product.getRelativeUrl())
-    self._makeSoftwareInstallation(self.new_id, computer,
+    self._makeSoftwareInstallation(self.generateNewId(), computer,
                                     software_release2.getUrlString())
     self.tic()
     
-    upgrade_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision.getSimulationState(), 'confirmed')
+    up_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()[0]
+    self.assertEqual(up_decision.getSimulationState(), 'confirmed')
     
-    self.assertEqual(upgrade_decision.UpgradeDecision_getHostingSubscription().\
+    self.assertEqual(up_decision.UpgradeDecision_getHostingSubscription().\
                       getReference(), hosting_subscription.getReference())
 
-    self.assertEqual(upgrade_decision.UpgradeDecision_getSoftwareRelease().\
+    self.assertEqual(up_decision.UpgradeDecision_getSoftwareRelease().\
                               getUrlString(), software_release2.getUrlString())
     
     self.tic()
-    upgrade_decision2 = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
-    self.assertEqual(upgrade_decision2, None)
+    up_decision2 = computer.Computer_hostingSubscriptionCreateUpgradeDecision()
+    self.assertEqual(len(up_decision2), 0)
+  
+  
+  def testComputer_hostingSubscriptionCreateUpgradeDecision_with_exist(self):
+    person = self._makePerson(self.new_id)
+    computer = self._makeComputer(self.new_id)
+    computer.edit(source_administration_value=person)
+    self._makeComputerPartitions(computer)
+    software_product = self._makeSoftwareProduct(self.new_id)
+    software_release = self._requestSoftwareRelease(self.new_id,
+                                    software_product.getRelativeUrl())
+    url_string = software_release.getUrlString()
+    
+    self._makeSoftwareInstallation(self.new_id, computer, url_string)
+    
+    # Create Hosting Subscription and Software Instance
+    hosting_subscription = self._makeFullHostingSubscription(self.new_id,
+                                    url_string, person)
+    self._makeFullSoftwareInstance(hosting_subscription, url_string)
+    self._markComputerPartitionBusy(computer,
+                                    hosting_subscription.getPredecessorValue())
+    
+    # Install the Newest software release
+    software_release2 = self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    self._makeSoftwareInstallation(self.generateNewId(), computer,
+                                    software_release2.getUrlString())
+    self.tic()
+    
+    up_decision = computer.Computer_hostingSubscriptionCreateUpgradeDecision()[0]
+    self.assertEqual(up_decision.getSimulationState(), 'confirmed')
+    
+    # Install the another software release
+    software_release3 = self._requestSoftwareRelease(self.generateNewId(),
+                                      software_product.getRelativeUrl())
+    self._makeSoftwareInstallation(self.generateNewId(), computer,
+                                    software_release3.getUrlString())
+    self.tic()
+    
+    up_decision2 = computer.Computer_hostingSubscriptionCreateUpgradeDecision()[0]
+    self.assertEqual(up_decision2.getSimulationState(), 'confirmed')
+    self.assertEqual(up_decision.getSimulationState(), 'cancelled')
+    release = up_decision2.UpgradeDecision_getSoftwareRelease()
+    self.assertEqual(release.getUrlString(),
+                                software_release3.getUrlString())
     
   
   def testBase_acceptUpgradeDecision_no_reference(self):
@@ -1116,3 +1328,5 @@ ${new_software_release_url}""",
        software_release.getUrlString()])
 
     self.assertEquals(event.getSimulationState(), "delivered")
+    
+    
\ No newline at end of file

master/bt5/slapos_pdm/bt/revision

-28
\ No newline at end of file
+33