Request state is now set to Complete only if the current version for the

request is complete

shared/workspaces/test/test_capability_request.py

@@ -16,7 +16,6 @@
 # You should have received a copy of the GNU General Public License
 # along with Workspaces.  If not, see <https://www.gnu.org/licenses/>.
 
-import random
 from typing import Dict
 
 from hypothesis import given
@@ -93,14 +92,12 @@ st.register_type_strategy(
 def test_determine_state_complete(mock_capability_info: CapabilityInfo, request_json: Dict, list_of_version_json: Dict):
     """
     Given: A capability request with multiple versions
-    When: QA is passed for the current version
-        And: The current version status is set to Complete
-        And: All other versions' statuses are set to Failed
+    When: The current version status is set to Complete
     Then: The request state should be set to Complete
     """
     request = CapabilityRequest.from_json(request_json)
     versions = [CapabilityVersion.from_json(blob) for blob in list_of_version_json]
-    version_to_pass = random.choice(versions)
+    current_version_number = max(version.version_number for version in versions)
 
     with clear_test_database(mock_capability_info):
         mock_capability_info.save_entity(request)
@@ -111,11 +108,9 @@ def test_determine_state_complete(mock_capability_info: CapabilityInfo, request_
             version.capability_request_id = request.id
 
             # Set one version to Complete, the rest to Failed or Executing
-            if version.version_number == version_to_pass.version_number:
-                print("Setting passing version to Complete")
+            if version.version_number == current_version_number:
                 version.state = CapabilityVersionState.Complete.name
             else:
-                print("Setting other version")
                 version.state = (
                     CapabilityVersionState.Failed.name
                     if version.state == CapabilityVersionState.Complete.name or not version.state

shared/workspaces/workspaces/capability/schema.py

@@ -477,18 +477,24 @@ class CapabilityRequest(Base, CapabilityRequestIF):
         - If all versions are created, the request is created
         - Otherwise, it is submitted
         """
+        logger.info("Determine request state...")
+        logger.info(f"Current version: {self.current_version.__json__()}")
         version_states = [version.state for version in self.versions]
 
-        if any(state == CapabilityVersionState.Complete.name for state in version_states):
-            # Request has a complete version, so it is complete
+        if self.current_version.state == CapabilityVersionState.Complete.name:
+            # The current version is complete, so the request is complete
+            logger.info("Current version is complete. Setting request to Complete.")
             self.state = CapabilityRequestState.Complete.name
         elif all(state == CapabilityRequestState.Failed.name for state in version_states):
             # Request has all failed versions, so it is failed
+            logger.info("All versions are failed. Setting request to Failed.")
             self.state = CapabilityRequestState.Failed.name
         elif all(state == CapabilityRequestState.Created.name for state in version_states):
             # Request has no submitted versions, so it is still in the created state
+            logger.info("All versions are created. Setting request to Created.")
             self.state = CapabilityRequestState.Created.name
         else:
+            logger.info("Versions are in a mixture of states. Setting request to Submitted.")
             self.state = CapabilityRequestState.Submitted.name
 
     def __str__(self):

shared/workspaces/workspaces/capability/services/capability_service.py

@@ -71,17 +71,17 @@ class CapabilityService(CapabilityServiceIF):
         logger.info(f"RECEIVED EXECUTION-COMPLETE: {message}")
 
         execution = message["subject"]
-
-        # Update request state
         capability_request = self.capability_info.lookup_capability_request(execution["capability_request_id"])
-        capability_request.determine_state()
-        self.capability_info.save_entity(capability_request)
+        version = self.capability_info.lookup_version(capability_request.id, execution["version_number"])
 
         # Set version state to Complete if the execution is indeed complete; else, leave it alone
-        version = self.capability_info.lookup_version(capability_request.id, execution["version_number"])
         version.state = CapabilityVersionState.Complete.name if execution["state_name"] == "Complete" else version.state
         self.capability_info.save_entity(version)
 
+        # Update request state
+        capability_request.determine_state()
+        self.capability_info.save_entity(capability_request)
+
         capability_complete_msg = CapabilityMessageArchitect(request=capability_request).compose_message(
             "capability_complete"
         )
@@ -92,17 +92,17 @@ class CapabilityService(CapabilityServiceIF):
         logger.info(f"RECEIVED EXECUTION-FAILED: {message}")
 
         execution = message["subject"]
-
-        # Update request state
         capability_request = self.capability_info.lookup_capability_request(execution["capability_request_id"])
-        capability_request.determine_state()
-        self.capability_info.save_entity(capability_request)
+        version = self.capability_info.lookup_version(capability_request.id, execution["version_number"])
 
         # Set version state to Failed
-        version = self.capability_info.lookup_version(capability_request.id, execution["version_number"])
         version.state = CapabilityVersionState.Failed.name
         self.capability_info.save_entity(version)
 
+        # Update request state
+        capability_request.determine_state()
+        self.capability_info.save_entity(capability_request)
+
         capability_failed_msg = CapabilityMessageArchitect(request=capability_request).compose_message(
             "capability_failed"
         )