cmd: tests

Author: xsmile

tests/integration/files/file/base/echo.ps1

@@ -0,0 +1,5 @@
+param (
+    [string]$a,
+    [string]$b
+)
+Write-Output "a: $a, b: $b"

tests/integration/files/file/base/echo.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+echo "a: $1, b: $2"

tests/integration/files/file/base/issue-35384.sls

@@ -1,6 +1,7 @@
 cmd_run_unless_multiple:
   cmd.run:
     - name: echo "hello"
+    - python_shell: True
     - unless:
   {% if grains["os"] ==  "Windows" %}
       - "exit 0"

tests/integration/states/test_cmd.py

@@ -1,5 +1,5 @@
 """
-Tests for the file state
+Tests for the cmd state
 """
 
 import errno
@@ -16,6 +16,10 @@
 from tests.support.mixins import SaltReturnAssertsMixin
 from tests.support.runtests import RUNTIME_VARS
 
+pytestmark = [
+    pytest.mark.windows_whitelisted,
+]
+
 
 class CMDTest(ModuleCase, SaltReturnAssertsMixin):
     """
@@ -25,12 +29,18 @@ class CMDTest(ModuleCase, SaltReturnAssertsMixin):
     @classmethod
     def setUpClass(cls):
         cls.__cmd = "dir" if salt.utils.platform.is_windows() else "ls"
+        cls.__python_shell = True if salt.utils.platform.is_windows() else False
 
     def test_run_simple(self):
         """
         cmd.run
         """
-        ret = self.run_state("cmd.run", name=self.__cmd, cwd=tempfile.gettempdir())
+        ret = self.run_state(
+            "cmd.run",
+            name=self.__cmd,
+            python_shell=self.__python_shell,
+            cwd=tempfile.gettempdir(),
+        )
         self.assertSaltTrueReturn(ret)
 
     def test_run_output_loglevel(self):
@@ -40,6 +50,7 @@ def test_run_output_loglevel(self):
         ret = self.run_state(
             "cmd.run",
             name=self.__cmd,
+            python_shell=self.__python_shell,
             cwd=tempfile.gettempdir(),
             output_loglevel="quiet",
         )
@@ -50,15 +61,24 @@ def test_run_simple_test_true(self):
         cmd.run test interface
         """
         ret = self.run_state(
-            "cmd.run", name=self.__cmd, cwd=tempfile.gettempdir(), test=True
+            "cmd.run",
+            name=self.__cmd,
+            python_shell=self.__python_shell,
+            cwd=tempfile.gettempdir(),
+            test=True,
         )
         self.assertSaltNoneReturn(ret)
 
     def test_run_hide_output(self):
         """
         cmd.run with output hidden
         """
-        ret = self.run_state("cmd.run", name=self.__cmd, hide_output=True)
+        ret = self.run_state(
+            "cmd.run",
+            name=self.__cmd,
+            python_shell=self.__python_shell,
+            hide_output=True,
+        )
         self.assertSaltTrueReturn(ret)
         ret = ret[next(iter(ret))]
         self.assertEqual(ret["changes"]["stdout"], "")
@@ -163,6 +183,7 @@ def test_run_creates_exists(self):
                 echo >> {0}:
                   cmd.run:
                     - creates: {0}
+                    - python_shell: True
                 """.format(
                             self.test_file
                         )
@@ -189,6 +210,7 @@ def test_run_creates_new(self):
                 echo >> {0}:
                   cmd.run:
                     - creates: {0}
+                    - python_shell: True
                 """.format(
                             self.test_file
                         )
@@ -214,7 +236,8 @@ def test_run_redirect(self):
                     textwrap.dedent(
                         """
                 echo test > {}:
-                  cmd.run
+                  cmd.run:
+                    - python_shell: True
                 """.format(
                             self.test_file
                         )
@@ -256,12 +279,14 @@ def test_run_watch(self):
                 saltines:
                   cmd.run:
                     - name: echo changed=true
+                    - python_shell: True
                     - cwd: /
                     - stateful: True
 
                 biscuits:
                   cmd.wait:
                     - name: echo biscuits
+                    - python_shell: True
                     - cwd: /
                     - watch:
                         - cmd: saltines
@@ -273,3 +298,112 @@ def test_run_watch(self):
         ret = self.run_function("state.sls", [self.state_name])
         self.assertTrue(ret[saltines_key]["result"])
         self.assertTrue(ret[biscuits_key]["result"])
+
+
+@pytest.mark.slow_test
+class CMDRun(ModuleCase, SaltReturnAssertsMixin):
+    """
+    Validate the run function of the cmd state
+    """
+
+    def test_run_shell(self):
+        expected = "foo bar"
+        ret = self.run_state(
+            "cmd.run",
+            name="echo foo bar",
+            python_shell=True,
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+    def test_run_no_shell(self):
+        ret = self.run_state(
+            "cmd.run",
+            name="whoami",
+            python_shell=False,
+        )
+        self.assertSaltTrueReturn(ret)
+
+    def test_run_no_shell_fail(self):
+        expected = "Unable to run command"
+        ret = self.run_state(
+            "cmd.run",
+            name="echo foo bar",
+        )
+        self.assertSaltFalseReturn(ret)
+        self.assertInSaltComment(expected, ret)
+
+    @pytest.mark.skip_on_windows
+    def test_run_args_string(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.run",
+            name="printf",
+            args='"a: %s, b: %s\n" "foo bar" "baz qux"',
+            python_shell=False,
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+    @pytest.mark.skip_on_windows
+    def test_run_args_list(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.run",
+            name="printf",
+            args=["a: %s, b: %s\n", "foo bar", "baz qux"],
+            python_shell=False,
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+
+@pytest.mark.slow_test
+class CMDScript(ModuleCase, SaltReturnAssertsMixin):
+    """
+    Validate the script function of the cmd state
+    """
+
+    @pytest.mark.skip_on_windows
+    def test_script_args_string(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.script",
+            name="salt://echo.sh",
+            args='"foo bar" "baz qux"',
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+    @pytest.mark.skip_unless_on_windows
+    def test_script_args_string_win(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.script",
+            name="salt://echo.ps1",
+            args='"foo bar" "baz qux"',
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+    @pytest.mark.skip_on_windows
+    def test_script_args_list(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.script",
+            name="salt://echo.sh",
+            args=["foo bar", "baz qux"],
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")
+
+    @pytest.mark.skip_unless_on_windows
+    def test_script_args_list_win(self):
+        expected = "a: foo bar, b: baz qux"
+        ret = self.run_state(
+            "cmd.script",
+            name="salt://echo.ps1",
+            args=["foo bar", "baz qux"],
+        )
+        self.assertSaltTrueReturn(ret)
+        self.assertSaltStateChangesEqual(ret, expected, "stdout")