Pushing with all successful test cases

Author: samyarpotlapalli

src/sasctl/_services/score_execution.py

@@ -62,44 +62,46 @@ def create_score_execution(
         if score_definition.status_code >= 400:
             raise HTTPError(score_definition.json())
         score_exec_name = score_definition.get("name")
-        model_uri = score_definition.get("objectDescriptor", ["uri"])
-        model_name = score_definition.get("objectDescriptor", ["name"])
-        model_input_library = score_definition.get("inputData", ["libraryName"])
-        model_table_name = score_definition.get("inputData", ["tableName"])
+        model_uri = score_definition.get("objectDescriptor", "uri")
+        model_name = score_definition.get("objectDescriptor", "name")
+        model_input_library = score_definition.get("inputData", "libraryName")
+        model_table_name = score_definition.get("inputData", "tableName")
 
         # Defining a default output table name if none is provided
         if not output_table_name:
             output_table_name = f"{model_name}_{score_definition_id}"
 
         # Getting all score executions that are using the inputted score_definition_id
-       
-        score_execution = cls.list_executions(filter=f"eq(scoreDefinitionId, '{score_definition_id}')")
+
+        score_execution = cls.list_executions(
+            filter=f"eq(scoreDefinitionId, '{score_definition_id}')"
+        )
         if score_execution.status_code >= 400:
             raise HTTPError(
-                    f"Something went wrong in the LIST_EXECUTIONS statement. See error: {score_execution.json()}"   
+                f"Something went wrong in the LIST_EXECUTIONS statement. See error: {score_execution.json()}"
             )
-        
+
         # Checking the count of the execution list to see if there are any score executions for this score_definition_id already running
         execution_count = score_execution.get("count")  # Exception catch location
         if execution_count == 1:
-            execution_id = score_execution.get("items", [0], ["id"])
+            execution_id = score_execution.get("items", 0, "id")
             deleted_execution = cls.delete_execution(execution_id)
             if deleted_execution.status_code >= 400:
                 raise HTTPError(
-                        f"Something went wrong in the DELETE statement. See error: {deleted_execution.json()}"
-                )       
+                    f"Something went wrong in the DELETE statement. See error: {deleted_execution.json()}"
+                )
 
         headers_score_exec = {"Content-Type": "application/json"}
 
         create_score_exec = {
-            "name": score_exec_name,
+            "name": f"{score_exec_name}",
             "description": description,
             "hints": {
-                "objectURI": model_uri,
-                "inputTableName": model_table_name,
-                "inputLibraryName": model_input_library,
+                "objectURI": f"{model_uri}",
+                "inputTableName": f"{model_table_name}",
+                "inputLibraryName": f"{model_input_library}",
             },
-            "scoreDefinitionId": score_definition_id,
+            "scoreDefinitionId": f"{score_definition_id}",
             "outputTable": {
                 "tableName": output_table_name,
                 "libraryName": output_library_name,

tests/unit/test_score_definitions.py

@@ -10,6 +10,7 @@
 import random
 import tempfile
 import unittest
+import copy
 from pathlib import Path
 from unittest import mock
 
@@ -31,44 +32,25 @@ def test_create_score_definition():
     - Invalid model id
     - Valid table name without input mapping
     - Invalid table name with invalid file
-    - Invalid table name with valid file and without input mapping
+    - Invalid table name with valid file
+    - Invalid table name without table file argument
 
     """
+    # Mocking a session to allow the post call to go through
     with mock.patch("sasctl.core.Session._get_authorization_token"):
         current_session("example.com", "username", "password")
-    
-    TARGET = {
-        "name": MODEL_NAME,
-        "projectId": PROJECT_ID,
-        "modeler": USER,
-        "description": "model description",
-        "function": "Classification",
-        "algorithm": "Dummy Algorithm",
-        "tool": "pytest",
-        "champion": True,
-        "role": "champion",
-        "immutable": True,
-        "retrainable": True,
-        "scoreCodeType": None,
-        "targetVariable": None,
-        "trainTable": None,
-        "classificationEventProbabilityVariableName": None,
-        "classificationTargetEventValue": None,
-        "location": None,
-        "properties": [
-            {"name": "custom1", "value": 123, "type": "numeric"},
-            {"name": "custom2", "value": "somevalue", "type": "string"},
-            # {'name': 'customDate', 'value': 1672462800000, 'type': 'date'},
-            {"name": "customDateTime", "value": 1672481272000, "type": "dateTime"},
-        ],
-        "inputVariables": [],
-        "outputVariables": [],
-        "version": 2,
-    }
 
-    # Passed params should be set correctly
-    target = copy.deepcopy(TARGET)
+    # TARGET = {
+    #         "mappings": [
+    #             {"mappingValue": "first", "mappingType": "datasource", "variableName": "first"},
+    #             {"mappingValue": "second", "mappingType": "datasource", "variableName": "second"},
+    #             {"mappingValue": "third", "mappingType": "datasource", "variableName": "third"}
+    #             ]
+    #     }
 
+    # target = copy.deepcopy(TARGET)
+
+    # Mocking the REST API calls and functions
     with mock.patch(
         "sasctl._services.model_repository.ModelRepository.get_model"
     ) as get_model:
@@ -81,6 +63,7 @@ def test_create_score_definition():
                 with mock.patch(
                     "sasctl._services.score_definitions.ScoreDefinitions.post"
                 ) as post:
+                    # Invalid model id test case
                     get_model.return_value.status_code = 404
                     with pytest.raises(HTTPError):
                         sd.create_score_definition(
@@ -89,6 +72,7 @@ def test_create_score_definition():
                             table_name="test_table",
                         )
 
+                    # Valid model id but invalid table name with no table_file argument test case
                     get_model.return_value.status_code = 200
                     get_model.return_value.json.return_value = {
                         "id": "12345",
@@ -103,6 +87,8 @@ def test_create_score_definition():
                             model_id="12345",
                             table_name="test_table",
                         )
+
+                    # Invalid table name with a table_file argument that doesn't work test case
                     get_table.return_value.status_code = 404
                     upload_file.return_value = None
                     get_table.return_value.status_code = 404
@@ -114,6 +100,7 @@ def test_create_score_definition():
                             table_file="test_path",
                         )
 
+                    # Valid table_file argument that successfully creates a table test case
                     get_table.return_value.status_code = 404
                     upload_file.return_value = RestObj
                     get_table.return_value.status_code = 200
@@ -128,6 +115,7 @@ def test_create_score_definition():
                     )
                     assert response
 
+                    # Valid table_name argument test case
                     get_table.return_value.status_code = 200
                     get_table.return_value.json.return_value = {
                         "tableName": "test_table"
@@ -140,6 +128,7 @@ def test_create_score_definition():
                     )
                     assert response
 
+                    # Checking response with inputVariables in model elements
                     get_model.return_value.status_code = 200
                     get_model.return_value.json.return_value = {
                         "id": "12345",
@@ -163,3 +152,7 @@ def test_create_score_definition():
                     )
                     assert response
                     assert post.call_count == 3
+
+                    # data = post.call_args
+                    # json_data = json.loads(data.kwargs["data"])
+                    # assert target["mappings"] == json_data["mappings"]

tests/unit/test_score_execution.py

@@ -10,6 +10,7 @@
 import random
 import tempfile
 import unittest
+import copy
 from pathlib import Path
 from unittest import mock
 from unittest.mock import MagicMock
@@ -26,21 +27,40 @@
 from sasctl._services.score_execution import ScoreExecution as se
 
 
+# Creating a CustomMock for list_executions to avoid a TypeError when comparing status code from mock with >= 400 in score_execution
+class CustomMock:
+    def __init__(self, status_code, json_info):
+        self.status_code = status_code
+        self.json_info = json_info
+
+    def get(self, key1, key2=None, key3=None):
+        if key2 is None and key3 is None:
+            return self.json_info[key1]
+        else:
+            return self.json_info[key1][key2][key3]
+
+
 def test_create_score_execution():
     """
     Test Cases:
-    - Valid score definition id?
-        -yes
-        -no
-    - Valid execution id?
-
-    -Valid count key? -> treated like input mapping -> no because i think it's required
-    - output table -> treat like input mapping but within the create_score_execution step (do I for library and server in score definition thought? but I think you need a target step here too)
+    - Valid score definition id and invalid list_executions argument
+    - Invalid score definition id
+    - Valid list_executions argument with execution already running but invalid delete_execution argument
+    - Valid list_executions argument with execution already running but valid delete_execution argument
+    - Valid list_executions argument without execution already running
+    - With output table specified within create_score_execution arguments
 
     """
+
+    # Mocking a session to allow the post call to go through
     with mock.patch("sasctl.core.Session._get_authorization_token"):
-        current_session("example.com", "username", "password")    
+        current_session("example.com", "username", "password")
+    # Mocking what a successful score execution post would be if the user specified an output table
+    TARGET = {"outputTable": {"tableName": "example_table"}}
+    # Creating a target to compare post call responses to
+    target = copy.deepcopy(TARGET)
 
+    # Mocking the REST API calls and functions
     with mock.patch(
         "sasctl._services.score_definitions.ScoreDefinitions.get_definition"
     ) as get_definition:
@@ -51,64 +71,72 @@ def test_create_score_execution():
                 "sasctl._services.score_execution.ScoreExecution.delete_execution"
             ) as delete_execution:
                 with mock.patch(
-                   "sasctl._services.score_execution.ScoreExecution.post" 
+                    "sasctl._services.score_execution.ScoreExecution.post"
                 ) as post:
+                    # Invalid score definition id test case
                     get_definition.return_value.status_code = 404
                     with pytest.raises(HTTPError):
-                        se.create_score_execution(
-                            score_definition_id="12345"
-                        )
+                        se.create_score_execution(score_definition_id="12345")
+
+                    # Valid score definition id and invalid list_executions argument test case
                     get_definition.return_value.status_code = 200
                     get_definition.return_value.json.return_value = {
                         "inputData": {
                             "libraryName": "cas-shared-default",
-                            "tableName": ""
+                            "tableName": "test_table",
                         },
                         "name": "score_def_name",
                         "objectDescriptor": {
                             "name": "test_model",
                             "type": "sas.publish.example",
-                            "uri": "/modelPublish/models/example"
-                         }
+                            "uri": "/modelPublish/models/example",
+                        },
                     }
-                    list_executions.return_value.status_code = 400 #test case worked with .return_value.status_code but caused an HTTP error that said error with list_Executions
+                    list_executions.return_value.status_code = 404
                     with pytest.raises(HTTPError):
-                        se.create_score_execution(
-                            score_definition_id="12345"
-                        )
+                        se.create_score_execution(score_definition_id="12345")
 
-                    list_executions.status_code = 200 #why does this not have a return value and how is this related to different score_Defintion instantiation in score_execution
-                    list_executions.return_value.json.return_value = {"count": 1}
+                    # Valid list_executions argument with execution already running but invalid delete_execution argument test case
+                    list_mock_execution = CustomMock(
+                        status_code=200,
+                        json_info={"count": 1, "items": [{"id": "1234"}]},
+                    )
+                    list_executions.return_value = list_mock_execution
                     delete_execution.return_value.status_code = 404
                     with pytest.raises(HTTPError):
-                        se.create_score_execution(
-                            score_definition_id="12345"
-                        )
-                    #Test cases that don't work or I haven't tested
-                    delete_execution.return_value.status_code = 200 
-                    response = se.create_score_execution(
-                        score_definition_id="3456"
+                        se.create_score_execution(score_definition_id="12345")
+
+                    # Valid list_executions argument with execution already running but valid delete_execution argument test case
+                    list_executions.return_value = list_mock_execution
+                    delete_execution.return_value.status_code = 200
+                    response = se.create_score_execution(score_definition_id="3456")
+                    assert response
+
+                    # Valid list_executions argument without execution already running test case
+                    list_mock_execution_diff_count = CustomMock(
+                        status_code=200,
+                        json_info={"count": 0, "items": [{"id": "1234"}]},
                     )
+                    list_executions.return_value = list_mock_execution_diff_count
+                    response = se.create_score_execution(score_definition_id="12345")
                     assert response
 
-                    list_executions.status_code = 200 #shouldn't this work with 200 response and not give me a type rror >= since it's not running 400 statement
-                    
-                    list_executions.return_value.json.return_value = {"count": 0}
+                    # Checking whether the output table name remained the default empty string or the default changed as writted in score_execution
+                    data = post.call_args
+                    json_data = json.loads(data.kwargs["data"])
+                    assert json_data["outputTable"]["tableName"] != ""
+
+                    # With output table specified within create_score_execution arguments test case
                     response = se.create_score_execution(
-                        score_definition_id="12345"
+                        score_definition_id="12345", output_table_name="example_table"
                     )
                     assert response
+                    assert post.call_count == 3
 
-                    list_executions.status_code = 200
-                    list_executions.return_value.json.return_value = {"count": 0}
-                    response = se.create_score_execution(
-                        score_definition_id="12345",
-                        output_table_name = "test_output_table"
+                    # Checking whether specified output table name or the default output table name is in the response
+                    data = post.call_args
+                    json_data = json.loads(data.kwargs["data"])
+                    assert (
+                        target["outputTable"]["tableName"]
+                        == json_data["outputTable"]["tableName"]
                     )
-                    assert response #target needed here to test with and without specified output_table_name
-                    
-                
-                #pytest.skip()
-                # raise HTTP error?
-#notes -> how to test count because it should only delete if count == 1 so how do I test that if/else
-#notes -> output table case, again TARGET?