coalib.tests.misc.RunShellCommandTest.test_run_interactive_shell_command() - Code Metrics - Inspection of "Makman2/anti-bash-injection" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1609)

by Mischa

created 2016-02-22 22:21 UTC

test_run_interactive_shell_command() A

↳ Parent: coalib.tests.misc.RunShellCommandTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	2
dl	0
loc	14
rs	9.4285

from contextlib import ExitStack
import os
import sys
from tempfile import NamedTemporaryFile
import unittest

from coalib.misc.Shell import (
    escape_path_argument, prepare_string_argument,
    run_interactive_shell_command, run_shell_command)


class EscapePathArgumentTest(unittest.TestCase):

    def test_escape_path_argument_sh(self):
        _type = "sh"
        self.assertEqual(
            escape_path_argument("/home/usr/a-file", _type),
            "/home/usr/a-file")
        self.assertEqual(
            escape_path_argument("/home/usr/a-dir/", _type),
            "/home/usr/a-dir/")
        self.assertEqual(
            escape_path_argument("/home/us r/a-file with spaces.bla",
                                 _type),
            "/home/us\\ r/a-file\\ with\\ spaces.bla")
        self.assertEqual(
            escape_path_argument("/home/us r/a-dir with spaces/x/",
                                 _type),
            "/home/us\\ r/a-dir\\ with\\ spaces/x/")
        self.assertEqual(
            escape_path_argument(
                "relative something/with cherries and/pickles.delicious",
                _type),
            "relative\\ something/with\\ cherries\\ and/pickles.delicious")

    def test_escape_path_argument_cmd(self):
        _type = "cmd"
        self.assertEqual(
            escape_path_argument("C:\\Windows\\has-a-weird-shell.txt", _type),
            "\"C:\\Windows\\has-a-weird-shell.txt\"")
        self.assertEqual(
            escape_path_argument("C:\\Windows\\lolrofl\\dirs\\", _type),
            "\"C:\\Windows\\lolrofl\\dirs\\\"")
        self.assertEqual(
            escape_path_argument("X:\\Users\\Maito Gai\\fi le.exe", _type),
            "\"X:\\Users\\Maito Gai\\fi le.exe\"")
        self.assertEqual(
            escape_path_argument("X:\\Users\\Mai to Gai\\director y\\",
                                 _type),
            "\"X:\\Users\\Mai to Gai\\director y\\\"")
        self.assertEqual(
            escape_path_argument("X:\\Users\\Maito Gai\\\"seven-gates\".y",
                                 _type),
            "\"X:\\Users\\Maito Gai\\^\"seven-gates^\".y\"")
        self.assertEqual(
            escape_path_argument("System32\\my-custom relative tool\\",
                                 _type),
            "\"System32\\my-custom relative tool\\\"")
        self.assertEqual(
            escape_path_argument("System32\\illegal\" name \"\".curd", _type),
            "\"System32\\illegal^\" name ^\"^\".curd\"")

    def test_escape_path_argument_unsupported(self):
        _type = "INVALID"
        self.assertEqual(
            escape_path_argument("/home/usr/a-file", _type),
            "/home/usr/a-file")
        self.assertEqual(
            escape_path_argument("/home/us r/a-file with spaces.bla", _type),
            "/home/us r/a-file with spaces.bla")
        self.assertEqual(
            escape_path_argument("|home|us r|a*dir with spaces|x|", _type),
            "|home|us r|a*dir with spaces|x|")
        self.assertEqual(
            escape_path_argument("system|a|b|c?d", _type),
            "system|a|b|c?d")


class RunShellCommandTest(unittest.TestCase):

    @staticmethod
    def construct_testscript_command(scriptname):
        return (sys.executable,
                os.path.join(os.path.dirname(os.path.realpath(__file__)),
                             "run_shell_command_testfiles",
                             scriptname))

    def test_run_interactive_shell_command(self):
        command = RunShellCommandTest.construct_testscript_command(
            "test_interactive_program.py")

        with run_interactive_shell_command(command) as p:
            self.assertEqual(p.stdout.readline(), "test_program X\n")
            self.assertEqual(p.stdout.readline(), "Type in a number:\n")
            p.stdin.write("33\n")
            p.stdin.flush()
            self.assertEqual(p.stdout.readline(), "33\n")
            self.assertEqual(p.stdout.readline(), "Exiting program.\n")

            self.assertEqual(p.stdout.read(), "")
            self.assertEqual(p.stderr.read(), "")

    def test_run_interactive_shell_command_custom_streams(self):
        command = RunShellCommandTest.construct_testscript_command(
            "test_interactive_program.py")

        with ExitStack() as stack:
            streams = {s: stack.enter_context(NamedTemporaryFile(mode="w+"))
                       for s in ["stdout", "stderr", "stdin"]}

            with run_interactive_shell_command(command, **streams) as p:
                streams["stdin"].write("712\n")
                streams["stdin"].flush()
                streams["stdin"].seek(0)

            self.assertFalse(streams["stdout"].closed)
            self.assertFalse(streams["stderr"].closed)
            self.assertFalse(streams["stdin"].closed)

            streams["stdout"].seek(0)
            self.assertEqual(streams["stdout"].read(),
                             "test_program X\nType in a number:\n712\n"
                             "Exiting program.\n")

            streams["stderr"].seek(0)
            self.assertEqual(streams["stderr"].read(), "")

    def test_run_interactive_shell_command_kwargs_delegation(self):
        with self.assertRaises(TypeError):
            with run_interactive_shell_command("some_command",
                                               weird_parameter=30):
                pass

    def test_run_shell_command_without_stdin(self):
        command = RunShellCommandTest.construct_testscript_command(
            "test_program.py")

        stdout, stderr = run_shell_command(command)

        expected = ("test_program Z\n"
                    "non-interactive mode.\n"
                    "Exiting...\n")
        self.assertEqual(stdout, expected)
        self.assertEqual(stderr, "")

    def test_run_shell_command_with_stdin(self):
        command = RunShellCommandTest.construct_testscript_command(
            "test_input_program.py")

        stdout, stderr = run_shell_command(command, "1  4  10  22")

        self.assertEqual(stdout, "37\n")
        self.assertEqual(stderr, "")

        stdout, stderr = run_shell_command(command, "1 p 5")

        self.assertEqual(stdout, "")
        self.assertEqual(stderr, "INVALID INPUT\n")

    def test_run_shell_command_kwargs_delegation(self):
        with self.assertRaises(TypeError):
            run_shell_command("super-cool-command", weird_parameter2="abc")


class PrepareStringArgumentTest(unittest.TestCase):

    def setUp(self):
        self.test_strings = ("normal_string",
                             "string with spaces",
                             'string with quotes"a',
                             "string with s-quotes'b",
                             "bsn \n A",
                             "unrecognized \\q escape")

    def test_prepare_string_argument_sh(self):
        expected_results = ('"normal_string"',
                            '"string with spaces"',
                            '"string with quotes\\"a"',
                            '"string with s-quotes\'b"',
                            '"bsn \n A"',
                            '"unrecognized \\q escape"')

        for string, result in zip(self.test_strings, expected_results):
            self.assertEqual(prepare_string_argument(string, "sh"),
                             result)

    def test_prepare_string_argument_unsupported(self):
        for string in self.test_strings:
            self.assertEqual(prepare_string_argument(string, "WeIrD_O/S"),
                             string)


1			from contextlib import ExitStack
2			import os
3			import sys
4			from tempfile import NamedTemporaryFile
5			import unittest
6
7			from coalib.misc.Shell import (
8			escape_path_argument, prepare_string_argument,
9			run_interactive_shell_command, run_shell_command)
10
11
12			class EscapePathArgumentTest(unittest.TestCase):
13
14			def test_escape_path_argument_sh(self):
15			_type = "sh"
16			self.assertEqual(
17			escape_path_argument("/home/usr/a-file", _type),
18			"/home/usr/a-file")
19			self.assertEqual(
20			escape_path_argument("/home/usr/a-dir/", _type),
21			"/home/usr/a-dir/")
22			self.assertEqual(
23			escape_path_argument("/home/us r/a-file with spaces.bla",
24			_type),
25			"/home/us\\ r/a-file\\ with\\ spaces.bla")
26			self.assertEqual(
27			escape_path_argument("/home/us r/a-dir with spaces/x/",
28			_type),
29			"/home/us\\ r/a-dir\\ with\\ spaces/x/")
30			self.assertEqual(
31			escape_path_argument(
32			"relative something/with cherries and/pickles.delicious",
33			_type),
34			"relative\\ something/with\\ cherries\\ and/pickles.delicious")
35
36			def test_escape_path_argument_cmd(self):
37			_type = "cmd"
38			self.assertEqual(
39			escape_path_argument("C:\\Windows\\has-a-weird-shell.txt", _type),
40			"\"C:\\Windows\\has-a-weird-shell.txt\"")
41			self.assertEqual(
42			escape_path_argument("C:\\Windows\\lolrofl\\dirs\\", _type),
43			"\"C:\\Windows\\lolrofl\\dirs\\\"")
44			self.assertEqual(
45			escape_path_argument("X:\\Users\\Maito Gai\\fi le.exe", _type),
46			"\"X:\\Users\\Maito Gai\\fi le.exe\"")
47			self.assertEqual(
48			escape_path_argument("X:\\Users\\Mai to Gai\\director y\\",
49			_type),
50			"\"X:\\Users\\Mai to Gai\\director y\\\"")
51			self.assertEqual(
52			escape_path_argument("X:\\Users\\Maito Gai\\\"seven-gates\".y",
53			_type),
54			"\"X:\\Users\\Maito Gai\\^\"seven-gates^\".y\"")
55			self.assertEqual(
56			escape_path_argument("System32\\my-custom relative tool\\",
57			_type),
58			"\"System32\\my-custom relative tool\\\"")
59			self.assertEqual(
60			escape_path_argument("System32\\illegal\" name \"\".curd", _type),
61			"\"System32\\illegal^\" name ^\"^\".curd\"")
62
63			def test_escape_path_argument_unsupported(self):
64			_type = "INVALID"
65			self.assertEqual(
66			escape_path_argument("/home/usr/a-file", _type),
67			"/home/usr/a-file")
68			self.assertEqual(
69			escape_path_argument("/home/us r/a-file with spaces.bla", _type),
70			"/home/us r/a-file with spaces.bla")
71			self.assertEqual(
72			escape_path_argument("\|home\|us r\|a*dir with spaces\|x\|", _type),
73			"\|home\|us r\|a*dir with spaces\|x\|")
74			self.assertEqual(
75			escape_path_argument("system\|a\|b\|c?d", _type),
76			"system\|a\|b\|c?d")
77
78
79			class RunShellCommandTest(unittest.TestCase):
80
81			@staticmethod
82			def construct_testscript_command(scriptname):
83			return (sys.executable,
84			os.path.join(os.path.dirname(os.path.realpath(__file__)),
85			"run_shell_command_testfiles",
86			scriptname))
87
88			def test_run_interactive_shell_command(self):
89			command = RunShellCommandTest.construct_testscript_command(
90			"test_interactive_program.py")
91
92			with run_interactive_shell_command(command) as p:
93			self.assertEqual(p.stdout.readline(), "test_program X\n")
94			self.assertEqual(p.stdout.readline(), "Type in a number:\n")
95			p.stdin.write("33\n")
96			p.stdin.flush()
97			self.assertEqual(p.stdout.readline(), "33\n")
98			self.assertEqual(p.stdout.readline(), "Exiting program.\n")
99
100			self.assertEqual(p.stdout.read(), "")
101			self.assertEqual(p.stderr.read(), "")
102
103			def test_run_interactive_shell_command_custom_streams(self):
104			command = RunShellCommandTest.construct_testscript_command(
105			"test_interactive_program.py")
106
107			with ExitStack() as stack:
108			streams = {s: stack.enter_context(NamedTemporaryFile(mode="w+"))
109			for s in ["stdout", "stderr", "stdin"]}
110
111			with run_interactive_shell_command(command, **streams) as p:
112			streams["stdin"].write("712\n")
113			streams["stdin"].flush()
114			streams["stdin"].seek(0)
115
116			self.assertFalse(streams["stdout"].closed)
117			self.assertFalse(streams["stderr"].closed)
118			self.assertFalse(streams["stdin"].closed)
119
120			streams["stdout"].seek(0)
121			self.assertEqual(streams["stdout"].read(),
122			"test_program X\nType in a number:\n712\n"
123			"Exiting program.\n")
124
125			streams["stderr"].seek(0)
126			self.assertEqual(streams["stderr"].read(), "")
127
128			def test_run_interactive_shell_command_kwargs_delegation(self):
129			with self.assertRaises(TypeError):
130			with run_interactive_shell_command("some_command",
131			weird_parameter=30):
132			pass
133
134			def test_run_shell_command_without_stdin(self):
135			command = RunShellCommandTest.construct_testscript_command(
136			"test_program.py")
137
138			stdout, stderr = run_shell_command(command)
139
140			expected = ("test_program Z\n"
141			"non-interactive mode.\n"
142			"Exiting...\n")
143			self.assertEqual(stdout, expected)
144			self.assertEqual(stderr, "")
145
146			def test_run_shell_command_with_stdin(self):
147			command = RunShellCommandTest.construct_testscript_command(
148			"test_input_program.py")
149
150			stdout, stderr = run_shell_command(command, "1 4 10 22")
151
152			self.assertEqual(stdout, "37\n")
153			self.assertEqual(stderr, "")
154
155			stdout, stderr = run_shell_command(command, "1 p 5")
156
157			self.assertEqual(stdout, "")
158			self.assertEqual(stderr, "INVALID INPUT\n")
159
160			def test_run_shell_command_kwargs_delegation(self):
161			with self.assertRaises(TypeError):
162			run_shell_command("super-cool-command", weird_parameter2="abc")
163
164
165			class PrepareStringArgumentTest(unittest.TestCase):
166
167			def setUp(self):
168			self.test_strings = ("normal_string",
169			"string with spaces",
170			'string with quotes"a',
171			"string with s-quotes'b",
172			"bsn \n A",
173			"unrecognized \\q escape")
174
175			def test_prepare_string_argument_sh(self):
176			expected_results = ('"normal_string"',
177			'"string with spaces"',
178			'"string with quotes\\"a"',
179			'"string with s-quotes\'b"',
180			'"bsn \n A"',
181			'"unrecognized \\q escape"')
182
183			for string, result in zip(self.test_strings, expected_results):
184			self.assertEqual(prepare_string_argument(string, "sh"),
185			result)
186
187			def test_prepare_string_argument_unsupported(self):
188			for string in self.test_strings:
189			self.assertEqual(prepare_string_argument(string, "WeIrD_O/S"),
190			string)
191

coala-analyzer / coala

Pull Request — master (#1609)

test_run_interactive_shell_command() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like