Change array and index_of tests

Author: Gijsreyn

dsc/tests/dsc_functions.tests.ps1

@@ -342,11 +342,10 @@ Describe 'tests for function expressions' {
   }
 
   It 'array function works for: <expression>' -TestCases @(
-    @{ expression = "[array('hello', 42)]"; expected = @('hello', 42) }
-    @{ expression = "[array('a', 'b', 'c')]"; expected = @('a', 'b', 'c') }
-    @{ expression = "[array(1, 2, 3)]"; expected = @(1, 2, 3) }
-    @{ expression = "[array('string', 123, createObject('key', 'value'))]"; expected = @('string', 123, [pscustomobject]@{ key = 'value' }) }
-    @{ expression = "[array(createArray('a', 'b'), 'string')]"; expected = @(@('a', 'b'), 'string') }
+    @{ expression = "[array('hello')]"; expected = @('hello') }
+    @{ expression = "[array(42)]"; expected = @(42) }
+    @{ expression = "[array(createObject('key', 'value'))]"; expected = @([pscustomobject]@{ key = 'value' }) }
+    @{ expression = "[array(createArray('a', 'b'))]"; expected = @(@('a', 'b')) }
   ) {
     param($expression, $expected)
 
@@ -408,4 +407,4 @@ Describe 'tests for function expressions' {
     $LASTEXITCODE | Should -Be 0 -Because (Get-Content $TestDrive/error.log -Raw)
     ($out.results[0].result.actualState.output | Out-String) | Should -BeExactly ($expected | Out-String)
   }
-}
+}

dsc_lib/locales/en-us.toml

@@ -218,7 +218,7 @@ description = "Evaluates if all arguments are true"
 invoked = "and function"
 
 [functions.array]
-description = "Creates an array from the given elements of mixed types"
+description = "Convert the value to an array"
 invoked = "array function"
 invalidArgType = "Invalid argument type, only int, string, array, or object are accepted"
 

dsc_lib/src/functions/array.rs

@@ -18,32 +18,25 @@ impl Function for Array {
             description: t!("functions.array.description").to_string(),
             category: FunctionCategory::Array,
             min_args: 1,
-            max_args: usize::MAX,
-            accepted_arg_ordered_types: vec![],
-            remaining_arg_accepted_types: Some(vec![
-                FunctionArgKind::String,
-                FunctionArgKind::Number,
-                FunctionArgKind::Object,
-                FunctionArgKind::Array,
-            ]),
+            max_args: 1,
+            accepted_arg_ordered_types: vec![
+                vec![FunctionArgKind::String, FunctionArgKind::Number, FunctionArgKind::Object, FunctionArgKind::Array],
+            ],
+            remaining_arg_accepted_types: None,
             return_types: vec![FunctionArgKind::Array],
         }
     }
 
     fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
         debug!("{}", t!("functions.array.invoked"));
-        let mut array_result = Vec::<Value>::new();
 
-        for value in args {
-            // Only accept int, string, array, or object as specified
-            if value.is_number() || value.is_string() || value.is_array() || value.is_object() {
-                array_result.push(value.clone());
-            } else {
-                return Err(DscError::Parser(t!("functions.array.invalidArgType").to_string()));
-            }
+        let value = &args[0];
+        
+        if value.is_number() || value.is_string() || value.is_array() || value.is_object() {
+            Ok(Value::Array(vec![value.clone()]))
+        } else {
+            Err(DscError::Parser(t!("functions.array.invalidArgType").to_string()))
         }
-
-        Ok(Value::Array(array_result))
     }
 }
 
@@ -53,31 +46,31 @@ mod tests {
     use crate::parser::Statement;
 
     #[test]
-    fn mixed_types() {
+    fn single_string() {
         let mut parser = Statement::new().unwrap();
-        let result = parser.parse_and_execute("[array('hello', 42)]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), r#"["hello",42]"#);
+        let result = parser.parse_and_execute("[array('hello')]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"["hello"]"#);
     }
 
     #[test]
-    fn strings_only() {
+    fn single_number() {
         let mut parser = Statement::new().unwrap();
-        let result = parser.parse_and_execute("[array('a', 'b', 'c')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), r#"["a","b","c"]"#);
+        let result = parser.parse_and_execute("[array(42)]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), "[42]");
     }
 
     #[test]
-    fn numbers_only() {
+    fn single_object() {
         let mut parser = Statement::new().unwrap();
-        let result = parser.parse_and_execute("[array(1, 2, 3)]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "[1,2,3]");
+        let result = parser.parse_and_execute("[array(createObject('key', 'value'))]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"[{"key":"value"}]"#);
     }
 
     #[test]
-    fn arrays_and_objects() {
+    fn single_array() {
         let mut parser = Statement::new().unwrap();
-        let result = parser.parse_and_execute("[array(createArray('a','b'), createObject('key', 'value'))]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), r#"[["a","b"],{"key":"value"}]"#);
+        let result = parser.parse_and_execute("[array(createArray('a','b'))]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"[["a","b"]]"#);
     }
 
     #[test]
@@ -87,6 +80,13 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn multiple_args_not_allowed() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[array('hello', 42)]", &Context::new());
+        assert!(result.is_err());
+    }
+
     #[test]
     fn invalid_type_boolean() {
         let mut parser = Statement::new().unwrap();

dsc_lib/src/functions/index_of.rs

@@ -60,56 +60,56 @@ mod tests {
     fn find_string_in_array() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray('apple', 'banana', 'cherry'), 'banana')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "1");
+        assert_eq!(result, 1);
     }
 
     #[test]
     fn find_number_in_array() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray(10, 20, 30), 20)]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "1");
+        assert_eq!(result, 1);
     }
 
     #[test]
     fn find_first_occurrence() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray('a', 'b', 'a', 'c'), 'a')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "0");
+        assert_eq!(result, 0);
     }
 
     #[test]
     fn item_not_found() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray('apple', 'banana'), 'orange')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "-1");
+        assert_eq!(result, -1);
     }
 
     #[test]
     fn case_sensitive_string() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray('Apple', 'Banana'), 'apple')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "-1");
+        assert_eq!(result, -1);
     }
 
     #[test]
     fn find_array_in_array() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(array(createArray('a', 'b'), createArray('c', 'd')), createArray('c', 'd'))]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "1");
+        assert_eq!(result, 1);
     }
 
     #[test]
     fn find_object_in_array() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(array(createObject('name', 'John'), createObject('name', 'Jane')), createObject('name', 'Jane'))]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "1");
+        assert_eq!(result, 1);
     }
 
     #[test]
     fn empty_array() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[indexOf(createArray(), 'test')]", &Context::new()).unwrap();
-        assert_eq!(result.to_string(), "-1");
+        assert_eq!(result, -1);
     }
 
     #[test]