Repository: microsoft/data-factory-testing-framework (language: python)

Issue:
Pipeline variable default values are ignored
During evaluate_pipeline all the run pipeline variables are created but defined default values are not set. Problem from my point of view is in _pipeline.py get_run_variables(), there it should be "defaultValue" not "default_value".

```python
run_variables.append(PipelineRunVariable(variable_name, variable_value.get("defaultValue", None)))
```


Discussion / hints:
@arjendev Here is a unit test to test the issue:

```
import pytest
from data_factory_testing_framework.models import Pipeline
from data_factory_testing_framework.state import RunParameter, RunParameterType


def test_when_variables_defaultvalues_are_correct_should_pass() -> None:
    # Arrange
    pipeline = Pipeline(
        pipeline_id="some-id",
        name="pipeline",
        activities=[],
        parameters=[]
    )

    pipeline.variables={
        "StringParam1": {
            "type": "String"
        },
        "StringParam2": {
            "type": "String",
            "defaultValue": "stringDefault"
        },
        "BoolParam1": {
            "type": "Boolean"
        },
        "BoolParam2": {
            "type": "Boolean",
            "defaultValue": True
        },
        "IntParam1": {
            "type": "Integer"
        },
        "IntParam2": {
            "type": "Integer",
            "defaultValue": 345
        },
        "ArrayParam1": {
            "type": "Array"
        },
        "ArrayParam2": {
            "type": "Array",
            "defaultValue": [
                "Val1",
                "Val2"
            ]
        }
    }

    # Act
    run_variables = pipeline.get_run_variables()

    # Assert
    assert len(run_variables) == 8
    assert run_variables[0].name == "StringParam1"    
    assert run_variables[0].value == None
    assert run_variables[1].name == "StringParam2"
    assert run_variables[1].value == "stringDefault"    
    assert run_variables[2].name == "BoolParam1"    
    assert run_variables[2].value == None
    assert run_variables[3].name == "BoolParam2"    
    assert run_variables[3].value == True
    assert run_variables[4].name == "IntParam1"    
    assert run_variables[4].value == None
    assert run_variables[5].name == "IntParam2"    
    assert run_variables[5].value == 345
    assert run_variables[6].name == "ArrayParam1"    
    assert run_variables[6].value == None
    assert run_variables[7].name == "ArrayParam2"    
    assert run_variables[7].value == ['Val1','Val2']
```
Thanks for elaborate example, we will fix this soon.

@LeonardHd will be updating `default_value` to `defaultValue` and write some tests to ensure things keep working!

Fix patch:
diff --git a/.vscode/settings.json b/.vscode/settings.json
index c79e8b8e..6d4e71b6 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -10,4 +10,5 @@
     "python.testing.cwd": "${workspaceFolder}",
     "python.testing.pytestEnabled": true,
     "python.testing.unittestEnabled": false,
+    "python.defaultInterpreterPath": ".venv/bin/python",
 }


Test patch:
diff --git a/src/data_factory_testing_framework/models/_pipeline.py b/src/data_factory_testing_framework/models/_pipeline.py
index e3518188..27527c64 100644
--- a/src/data_factory_testing_framework/models/_pipeline.py
+++ b/src/data_factory_testing_framework/models/_pipeline.py
@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, List
+from typing import TYPE_CHECKING, Any, List, Union
 
 from data_factory_testing_framework.exceptions import ActivityNotFoundError
 
@@ -79,10 +79,25 @@ def validate_and_append_default_parameters(self, parameters: List[RunParameter])
 
         return parameters
 
+    def _get_default_value_for_variable(self, variable_value: dict[str, Any]) -> Union[str, int, bool, List[Any]]:
+        """Get the default value of a variable."""
+        if variable_value["type"] == "String":
+            return variable_value.get("defaultValue", "")
+        elif variable_value["type"] == "Integer":
+            return variable_value.get("defaultValue", 0)
+        elif variable_value["type"] == "Boolean":
+            return variable_value.get("defaultValue", False)
+        elif variable_value["type"] == "Array":
+            return variable_value.get("defaultValue", [])
+        else:
+            raise NotImplementedError(f"Type {variable_value['type']} not implemented")
+
     def get_run_variables(self) -> List[PipelineRunVariable]:
         """Get the run variables for the pipeline. This can be used to generate the instance variables for a pipeline run."""
         run_variables = []
         for variable_name, variable_value in self.variables.items():
-            run_variables.append(PipelineRunVariable(variable_name, variable_value.get("default_value", None)))
+            run_variables.append(
+                PipelineRunVariable(variable_name, self._get_default_value_for_variable(variable_value))
+            )
 
         return run_variables
diff --git a/tests/functional/variables_default_value/pipeline/default_variables.json b/tests/functional/variables_default_value/pipeline/default_variables.json
new file mode 100644
index 00000000..a280ad50
--- /dev/null
+++ b/tests/functional/variables_default_value/pipeline/default_variables.json
@@ -0,0 +1,114 @@
+{
+    "name": "default_variables",
+    "properties": {
+        "activities": [
+            {
+                "name": "Set outputStringVar",
+                "type": "SetVariable",
+                "dependsOn": [],
+                "policy": {
+                    "secureOutput": false,
+                    "secureInput": false
+                },
+                "userProperties": [],
+                "typeProperties": {
+                    "variableName": "pipelineReturnValue",
+                    "value": [
+                        {
+                            "key": "outputStringVar",
+                            "value": {
+                                "type": "Expression",
+                                "content": "@if(equals(variables('stringVar'), null), 'is null', concat('is not null: ', variables('stringVar')))\n"
+                            }
+                        }
+                    ],
+                    "setSystemVariable": true
+                }
+            },
+            {
+                "name": "Set outputIntVar",
+                "type": "SetVariable",
+                "dependsOn": [],
+                "policy": {
+                    "secureOutput": false,
+                    "secureInput": false
+                },
+                "userProperties": [],
+                "typeProperties": {
+                    "variableName": "pipelineReturnValue",
+                    "value": [
+                        {
+                            "key": "outputIntVar",
+                            "value": {
+                                "type": "Expression",
+                                "content": "@if(equals(variables('intVar'), null), 'is null', concat('is not null: ', variables('intVar')))\n"
+                            }
+                        }
+                    ],
+                    "setSystemVariable": true
+                }
+            },
+            {
+                "name": "Set outputBoolVar",
+                "type": "SetVariable",
+                "dependsOn": [],
+                "policy": {
+                    "secureOutput": false,
+                    "secureInput": false
+                },
+                "userProperties": [],
+                "typeProperties": {
+                    "variableName": "pipelineReturnValue",
+                    "value": [
+                        {
+                            "key": "outputBoolVar",
+                            "value": {
+                                "type": "Expression",
+                                "content": "@if(equals(variables('boolVar'), null), 'is null', concat('is not null: ', variables('boolVar')))\n"
+                            }
+                        }
+                    ],
+                    "setSystemVariable": true
+                }
+            },
+            {
+                "name": "Set outputArrayVar",
+                "type": "SetVariable",
+                "dependsOn": [],
+                "policy": {
+                    "secureOutput": false,
+                    "secureInput": false
+                },
+                "userProperties": [],
+                "typeProperties": {
+                    "variableName": "pipelineReturnValue",
+                    "value": [
+                        {
+                            "key": "outputArrayVar",
+                            "value": {
+                                "type": "Expression",
+                                "content": "@if(equals(variables('arrayVar'), null), 'is null', concat('is not null: ', variables('arrayVar')))\n"
+                            }
+                        }
+                    ],
+                    "setSystemVariable": true
+                }
+            }
+        ],
+        "variables": {
+            "stringVar": {
+                "type": "String"
+            },
+            "intVar": {
+                "type": "Integer"
+            },
+            "boolVar": {
+                "type": "Boolean"
+            },
+            "arrayVar": {
+                "type": "Array"
+            }
+        },
+        "annotations": []
+    }
+}
diff --git a/tests/functional/variables_default_value/test_variables_default.py b/tests/functional/variables_default_value/test_variables_default.py
new file mode 100644
index 00000000..6d5cec81
--- /dev/null
+++ b/tests/functional/variables_default_value/test_variables_default.py
@@ -0,0 +1,40 @@
+import pytest
+from data_factory_testing_framework import TestFramework, TestFrameworkType
+
+
+def test_string_default_variables(request: pytest.FixtureRequest) -> None:
+    # Arrange
+    test_framework = TestFramework(
+        framework_type=TestFrameworkType.DataFactory, root_folder_path=request.fspath.dirname
+    )
+    pipeline = test_framework.get_pipeline_by_name("default_variables")
+
+    # Act
+    activities = test_framework.evaluate_pipeline(
+        pipeline,
+        [],
+    )
+
+    # Assert
+    activity = next(activities)
+    assert activity.name == "Set outputStringVar"
+    assert activity.type_properties["value"][0]["key"] == "outputStringVar"
+    assert activity.type_properties["value"][0]["value"].result == "is not null: "
+
+    activity = next(activities)
+    assert activity.name == "Set outputIntVar"
+    assert activity.type_properties["value"][0]["key"] == "outputIntVar"
+    assert activity.type_properties["value"][0]["value"].result == "is not null: 0"
+
+    activity = next(activities)
+    assert activity.name == "Set outputBoolVar"
+    assert activity.type_properties["value"][0]["key"] == "outputBoolVar"
+    assert activity.type_properties["value"][0]["value"].result == "is not null: False"
+
+    activity = next(activities)
+    assert activity.name == "Set outputArrayVar"
+    assert activity.type_properties["value"][0]["key"] == "outputArrayVar"
+    assert activity.type_properties["value"][0]["value"].result == "is not null: []"
+
+    with pytest.raises(StopIteration):
+        next(activities)
diff --git a/tests/unit/models/pipelines/test_pipeline_resource.py b/tests/unit/models/pipelines/test_pipeline_resource.py
index a8e05f97..a07b8444 100644
--- a/tests/unit/models/pipelines/test_pipeline_resource.py
+++ b/tests/unit/models/pipelines/test_pipeline_resource.py
@@ -41,6 +41,92 @@ def test_when_validate_parameters_is_accurate_should_pass() -> None:
     assert parameters[2].value == "pipelineParameterValue3"
 
 
+@pytest.mark.parametrize(
+    ("variable_spec", "expected_value"),
+    [
+        (
+            {
+                "type": "String",
+                "defaultValue": "stringDefault",
+            },
+            "stringDefault",
+        ),
+        (
+            {
+                "type": "String",
+            },
+            "",
+        ),
+        (
+            {
+                "type": "String",
+                "defaultValue": "",
+            },
+            "",
+        ),
+        (
+            {
+                "type": "Boolean",
+                "defaultValue": True,
+            },
+            True,
+        ),
+        (
+            {
+                "type": "Boolean",
+            },
+            False,
+        ),
+        (
+            {
+                "type": "Integer",
+                "defaultValue": 1,
+            },
+            1,
+        ),
+        (
+            {
+                "type": "Integer",
+            },
+            0,
+        ),
+        (
+            {
+                "type": "Array",
+                "defaultValue": ["a", "b"],
+            },
+            ["a", "b"],
+        ),
+        (
+            {
+                "type": "Array",
+            },
+            [],
+        ),
+    ],
+)
+def test_when_get_run_variables_default_values_should_be_used(
+    variable_spec: dict[str, str], expected_value: object
+) -> None:
+    # Arrange
+    pipeline = Pipeline(
+        pipeline_id="some-id",
+        name="pipeline",
+        activities=[],
+        variables={
+            "variable": variable_spec,
+        },
+    )
+
+    # Act
+    variables = pipeline.get_run_variables()
+
+    # Assert
+    assert len(variables) == 1
+    assert variables[0].name == "variable"
+    assert variables[0].value == expected_value
+
+
 def test_when_validate_parameters_is_missing_run_parameter_should_throw_error() -> None:
     # Arrange
     pipeline = Pipeline(