Cleaned up test documentation (ref #31).

nigel.stanger / process_podcast

Browse code Cleaned up test documentation (ref #31). master
1 parent 105ea08 commit c811fa59d21738f1479cfed4cfd6bc1f5c974567 Nigel Stanger authored on 20 Sep 2018

Patch

Showing 5 changed files

Ignore Space Show notes View test_convert_command.py
import shutil import unittest from shell_command import ConvertCommand from test_shared import ShellCommandSharedTestCase class ConvertCommandTestCase(ShellCommandSharedTestCase): """Test the ConvertCommand class.""" def setUp(self): """Set up for test.""" # Make sure the input and output options are explicitly set, # otherwise they hang around from previous tests. self.command = ConvertCommand( input_options=["in.pdf[12]"], output_options=["out.png"]) self.expected_executable = shutil.which("convert") self.expected_base_options = [ "-size", "2048x1536", "-density", "600", "xc:dimgrey", "null:", "(" ] self.expected_input_options = [ "in.pdf[12]", "-resize", "2048x1536", "-background", "white", "-alpha", "remove", "-type", "truecolor", "-define", "colorspace:auto-grayscale=off", ] self.expected_filter_options = [] self.expected_output_options = [ ")", "-gravity", "center", "-layers", "composite", "-flatten", "out.png", ] def tearDown(self): """Clean up after test.""" self.command = None # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase) import shutil import unittest from shell_command import ConvertCommand from test_shared import ShellCommandSharedTestCase class ConvertCommandTestCase(ShellCommandSharedTestCase): """Test the ConvertCommand class. """ def setUp(self): """Initialisation. Make sure the input and output options are explicitly set otherwise they hang around from previous tests. """ self.command = ConvertCommand( input_options=["in.pdf[12]"], output_options=["out.png"]) self.expected_executable = shutil.which("convert") self.expected_base_options = [ "-size", "2048x1536", "-density", "600", "xc:dimgrey", "null:", "(" ] self.expected_input_options = [ "in.pdf[12]", "-resize", "2048x1536", "-background", "white", "-alpha", "remove", "-type", "truecolor", "-define", "colorspace:auto-grayscale=off", ] self.expected_filter_options = [] self.expected_output_options = [ ")", "-gravity", "center", "-layers", "composite", "-flatten", "out.png", ] def tearDown(self): """Cleanup. """ self.command = None # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase)

Ignore Space Show notes View

test_convert_command.py

import shutil
import unittest

from shell_command import ConvertCommand
from test_shared import ShellCommandSharedTestCase

class ConvertCommandTestCase(ShellCommandSharedTestCase):
    """Test the ConvertCommand class."""

def setUp(self):
        """Set up for test."""
        # Make sure the input and output options are explicitly set,
        # otherwise they hang around from previous tests.
        self.command = ConvertCommand(
            input_options=["in.pdf[12]"], output_options=["out.png"])
        self.expected_executable = shutil.which("convert")
        self.expected_base_options = [
            "-size", "2048x1536",
            "-density", "600",
            "xc:dimgrey", "null:",
            "("
        ]
        self.expected_input_options = [
            "in.pdf[12]",
            "-resize", "2048x1536",
            "-background", "white", 
            "-alpha", "remove",
            "-type", "truecolor",
            "-define", "colorspace:auto-grayscale=off",
        ]
        self.expected_filter_options = []
        self.expected_output_options = [
            ")",
            "-gravity", "center",
            "-layers", "composite",
            "-flatten",
            "out.png",
        ]

def tearDown(self):
        """Clean up after test."""
        self.command = None

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

import shutil
import unittest

from shell_command import ConvertCommand
from test_shared import ShellCommandSharedTestCase

class ConvertCommandTestCase(ShellCommandSharedTestCase):
    """Test the ConvertCommand class.
    """

def setUp(self):
        """Initialisation. Make sure the input and output options are
        explicitly set otherwise they hang around from previous tests.
        """
        self.command = ConvertCommand(
            input_options=["in.pdf[12]"], output_options=["out.png"])
        self.expected_executable = shutil.which("convert")
        self.expected_base_options = [
            "-size", "2048x1536",
            "-density", "600",
            "xc:dimgrey", "null:",
            "("
        ]
        self.expected_input_options = [
            "in.pdf[12]",
            "-resize", "2048x1536",
            "-background", "white", 
            "-alpha", "remove",
            "-type", "truecolor",
            "-define", "colorspace:auto-grayscale=off",
        ]
        self.expected_filter_options = []
        self.expected_output_options = [
            ")",
            "-gravity", "center",
            "-layers", "composite",
            "-flatten",
            "out.png",
        ]

def tearDown(self):
        """Cleanup.
        """
        self.command = None

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

Ignore Space Show notes View test_ffmpeg_command.py
import shutil from pathlib import Path import tempfile import unittest from shell_command import FFmpegCommand from test_shared import ShellCommandSharedTestCase class FFmpegCommandTestCase(ShellCommandSharedTestCase): """Test the FFmpegCommand class.""" def setUp(self): """Set up for test.""" # Make sure the input and output options are explicitly set, # otherwise they hang around from previous tests. self.command = FFmpegCommand( input_options=["-i", "in.mov"], output_options=["out.mov"]) self.expected_executable = shutil.which("ffmpeg") self.expected_base_options = ["-y", "-nostdin",] self.expected_input_options = ["-i", "in.mov"] self.expected_filter_options = [] self.expected_output_options = ["out.mov"] def tearDown(self): """Clean up after test.""" self.command = None # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase) import shutil from pathlib import Path import tempfile import unittest from shell_command import FFmpegCommand from test_shared import ShellCommandSharedTestCase class FFmpegCommandTestCase(ShellCommandSharedTestCase): """Test the FFmpegCommand class. """ def setUp(self): """Initialisation. Make sure the input and output options are explicitly set otherwise they hang around from previous tests. A fresh temporary file is created for each test. """ self.command = FFmpegCommand( input_options=["-i", "in.mov"], output_options=["out.mov"]) self.expected_executable = shutil.which("ffmpeg") self.expected_base_options = ["-y", "-nostdin",] self.expected_input_options = ["-i", "in.mov"] self.expected_filter_options = [] self.expected_output_options = ["out.mov"] def tearDown(self): """Cleanup. """ self.command = None # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase)

Ignore Space Show notes View

test_ffmpeg_command.py

import shutil
from pathlib import Path
import tempfile
import unittest

from shell_command import FFmpegCommand
from test_shared import ShellCommandSharedTestCase

class FFmpegCommandTestCase(ShellCommandSharedTestCase):
    """Test the FFmpegCommand class."""

def setUp(self):
        """Set up for test."""
        # Make sure the input and output options are explicitly set,
        # otherwise they hang around from previous tests.
        self.command = FFmpegCommand(
            input_options=["-i", "in.mov"], output_options=["out.mov"])
        self.expected_executable = shutil.which("ffmpeg")
        self.expected_base_options = ["-y", "-nostdin",]
        self.expected_input_options = ["-i", "in.mov"]
        self.expected_filter_options = []
        self.expected_output_options = ["out.mov"]

def tearDown(self):
        """Clean up after test."""
        self.command = None

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

import shutil
from pathlib import Path
import tempfile
import unittest

from shell_command import FFmpegCommand
from test_shared import ShellCommandSharedTestCase

class FFmpegCommandTestCase(ShellCommandSharedTestCase):
    """Test the FFmpegCommand class.
    """

def setUp(self):
        """Initialisation. Make sure the input and output options are
        explicitly set otherwise they hang around from previous tests.
        A fresh temporary file is created for each test.
        """
        self.command = FFmpegCommand(
            input_options=["-i", "in.mov"], output_options=["out.mov"])
        self.expected_executable = shutil.which("ffmpeg")
        self.expected_base_options = ["-y", "-nostdin",]
        self.expected_input_options = ["-i", "in.mov"]
        self.expected_filter_options = []
        self.expected_output_options = ["out.mov"]

def tearDown(self):
        """Cleanup.
        """
        self.command = None

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

Ignore Space Show notes View test_ffprobe_command.py
import shutil from pathlib import Path import tempfile import unittest from shell_command import FFprobeCommand from test_shared import ShellCommandSharedTestCase class FFprobeCommandTestCase(ShellCommandSharedTestCase): """Test the FFprobeCommand class.""" def setUp(self): """Set up for test.""" # Make sure the input and output options are explicitly set, # otherwise they hang around from previous tests. A fresh # temporary file is created for each test. self.tmpfile = tempfile.NamedTemporaryFile() self.command = FFprobeCommand( input_options=["-i", self.tmpfile.name], output_options=[]) self.expected_executable = shutil.which("ffprobe") self.expected_base_options = [ "-loglevel", "error", "-show_entries", "format:stream", "-print_format", "json", ] self.expected_input_options = ["-i", self.tmpfile.name] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Clean up after test.""" self.tmpfile.close() self.command = None def test_last_modified(self): """Test that last modified time of temp file matches.""" self.assertEqual( self.command.last_modified, Path(self.tmpfile.name).stat().st_mtime) # get_entries()? # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase) import shutil from pathlib import Path import tempfile import unittest from shell_command import FFprobeCommand from test_shared import ShellCommandSharedTestCase class FFprobeCommandTestCase(ShellCommandSharedTestCase): """Test the FFprobeCommand class. """ def setUp(self): """Initialisation. Make sure the input and output options are explicitly set otherwise they hang around from previous tests. A fresh temporary file is created for each test. """ self.tmpfile = tempfile.NamedTemporaryFile() self.command = FFprobeCommand( input_options=["-i", self.tmpfile.name], output_options=[]) self.expected_executable = shutil.which("ffprobe") self.expected_base_options = [ "-loglevel", "error", "-show_entries", "format:stream", "-print_format", "json", ] self.expected_input_options = ["-i", self.tmpfile.name] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Cleanup. """ self.tmpfile.close() self.command = None def test_last_modified(self): """Test that last modified time matches tmpfile on disk. """ self.assertEqual( self.command.last_modified, Path(self.tmpfile.name).stat().st_mtime) # get_entries()? # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase)

Ignore Space Show notes View

test_ffprobe_command.py

import shutil
from pathlib import Path
import tempfile
import unittest

from shell_command import FFprobeCommand
from test_shared import ShellCommandSharedTestCase

class FFprobeCommandTestCase(ShellCommandSharedTestCase):
    """Test the FFprobeCommand class."""

def setUp(self):
        """Set up for test."""
        # Make sure the input and output options are explicitly set,
        # otherwise they hang around from previous tests. A fresh
        # temporary file is created for each test.
        self.tmpfile = tempfile.NamedTemporaryFile()
        self.command = FFprobeCommand(
            input_options=["-i", self.tmpfile.name], output_options=[])
        self.expected_executable = shutil.which("ffprobe")
        self.expected_base_options = [
            "-loglevel", "error",
            "-show_entries", "format:stream",
            "-print_format", "json",
        ]
        self.expected_input_options = ["-i", self.tmpfile.name]
        self.expected_filter_options = []
        self.expected_output_options = []

def tearDown(self):
        """Clean up after test."""
        self.tmpfile.close()
        self.command = None
    
    def test_last_modified(self):
        """Test that last modified time of temp file matches."""
        self.assertEqual(
            self.command.last_modified,
            Path(self.tmpfile.name).stat().st_mtime)

# get_entries()?

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

import shutil
from pathlib import Path
import tempfile
import unittest

from shell_command import FFprobeCommand
from test_shared import ShellCommandSharedTestCase

class FFprobeCommandTestCase(ShellCommandSharedTestCase):
    """Test the FFprobeCommand class.
    """

def setUp(self):
        """Initialisation. Make sure the input and output options are
        explicitly set otherwise they hang around from previous tests.
        A fresh temporary file is created for each test.
        """
        self.tmpfile = tempfile.NamedTemporaryFile()
        self.command = FFprobeCommand(
            input_options=["-i", self.tmpfile.name], output_options=[])
        self.expected_executable = shutil.which("ffprobe")
        self.expected_base_options = [
            "-loglevel", "error",
            "-show_entries", "format:stream",
            "-print_format", "json",
        ]
        self.expected_input_options = ["-i", self.tmpfile.name]
        self.expected_filter_options = []
        self.expected_output_options = []

def tearDown(self):
        """Cleanup.
        """
        self.tmpfile.close()
        self.command = None
    
    def test_last_modified(self):
        """Test that last modified time matches tmpfile on disk.
        """
        self.assertEqual(
            self.command.last_modified,
            Path(self.tmpfile.name).stat().st_mtime)

# get_entries()?

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

Ignore Space Show notes View test_shared.py
import unittest from shell_command import ShellCommand class ShellCommandSharedTestCase(unittest.TestCase): """Shared tests for ShellCommand and its subclasses.""" def setUp(self): """Set up for test.""" # Make sure the input and output options are explicitly set to # [] otherwise they hang around from previous tests. self.command = ShellCommand(input_options=[], output_options=[]) self.expected_executable = "" self.expected_base_options = [] self.expected_input_options = [] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Clean up after test.""" self.command = None def test_base_options(self): """Test that base options match expected.""" self.assertEqual( self.command._base_options, self.expected_base_options) def test_input_options(self): """Test that input options match expected.""" self.assertEqual( self.command.input_options, self.expected_input_options) def test_output_options(self): """Test that output options match expected.""" self.assertEqual( self.command.output_options, self.expected_output_options) def test_executable_string(self): """Test that executable path matches expected.""" with self.subTest(msg="unquoted"): self.assertEqual(self.command.executable_string(quote=False), self.expected_executable) with self.subTest(msg="quoted"): # Note: don't explicitly specify quoted value, because # the executable path will vary across different systems. self.assertEqual(self.command.executable_string(quote=True), ShellCommand.shellquote(self.expected_executable)) def test_argument_string(self): """Test that argument string matches expected.""" args = (self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) with self.subTest(msg="unquoted"): self.assertEqual(self.command.argument_string(quote=False), " ".join(args)) with self.subTest(msg="quoted"): self.assertEqual(self.command.argument_string(quote=True), " ".join([ShellCommand.shellquote(a) for a in args])) def test_argument_list(self): """Test that argument list matches expected.""" self.assertEqual(self.command.argument_list(), self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) def test_command_string(self): """Test that command string matches expected.""" args = (self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) expected_cmd_unquoted = ( "{exe} {arg}".format(exe=self.expected_executable, arg=" ".join(args)) ) expected_cmd_quoted = ( '{exe} {arg}'.format( exe=ShellCommand.shellquote(self.expected_executable), arg=" ".join([ShellCommand.shellquote(a) for a in args])) ) with self.subTest(msg="unquoted"): self.assertEqual(self.command.command_string(quote=False), expected_cmd_unquoted) with self.subTest(msg="quoted"): self.assertEqual(self.command.command_string(quote=True), expected_cmd_quoted) import unittest from shell_command import ShellCommand class ShellCommandSharedTestCase(unittest.TestCase): """Shared tests for ShellCommand and its subclasses. """ def setUp(self): """Initialisation. Make sure the input and output options are explicitly set to [] otherwise they hang around from previous tests. """ self.command = ShellCommand(input_options=[], output_options=[]) self.expected_executable = "" self.expected_base_options = [] self.expected_input_options = [] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Cleanup. """ self.command = None def test_base_options(self): """Test that base options match expected. """ self.assertEqual( self.command._base_options, self.expected_base_options) def test_input_options(self): """Test that input options match expected. """ self.assertEqual( self.command.input_options, self.expected_input_options) def test_output_options(self): """Test that output options match expected. """ self.assertEqual( self.command.output_options, self.expected_output_options) def test_executable_string(self): """Test that executable path matches expected. """ with self.subTest(msg="unquoted"): self.assertEqual(self.command.executable_string(quote=False), self.expected_executable) with self.subTest(msg="quoted"): # Note: don't explicitly specify quoted value, because # the executable path will vary across different systems. self.assertEqual(self.command.executable_string(quote=True), ShellCommand.shellquote(self.expected_executable)) def test_argument_string(self): """Test that the argument string matches expected. """ args = (self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) with self.subTest(msg="unquoted"): self.assertEqual(self.command.argument_string(quote=False), " ".join(args)) with self.subTest(msg="quoted"): self.assertEqual(self.command.argument_string(quote=True), " ".join([ShellCommand.shellquote(a) for a in args])) def test_argument_list(self): """Test that the argument list matches expected. """ self.assertEqual(self.command.argument_list(), self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) def test_command_string(self): """Test that the command string matches expected. """ args = (self.expected_base_options + self.expected_input_options + self.expected_filter_options + self.expected_output_options) expected_cmd_unquoted = ( "{exe} {arg}".format(exe=self.expected_executable, arg=" ".join(args)) ) expected_cmd_quoted = ( '{exe} {arg}'.format( exe=ShellCommand.shellquote(self.expected_executable), arg=" ".join([ShellCommand.shellquote(a) for a in args])) ) with self.subTest(msg="unquoted"): self.assertEqual(self.command.command_string(quote=False), expected_cmd_unquoted) with self.subTest(msg="quoted"): self.assertEqual(self.command.command_string(quote=True), expected_cmd_quoted)

Ignore Space Show notes View

test_shared.py

import unittest

from shell_command import ShellCommand

class ShellCommandSharedTestCase(unittest.TestCase):
    """Shared tests for ShellCommand and its subclasses."""

def setUp(self):
        """Set up for test."""
        # Make sure the input and output options are explicitly set to
        # [] otherwise they hang around from previous tests.
        self.command = ShellCommand(input_options=[], output_options=[])
        self.expected_executable = ""
        self.expected_base_options = []
        self.expected_input_options = []
        self.expected_filter_options = []
        self.expected_output_options = []

def tearDown(self):
        """Clean up after test."""
        self.command = None

def test_base_options(self):
        """Test that base options match expected."""
        self.assertEqual(
            self.command._base_options, self.expected_base_options)
    
    def test_input_options(self):
        """Test that input options match expected."""
        self.assertEqual(
            self.command.input_options, self.expected_input_options)
    
    def test_output_options(self):
        """Test that output options match expected."""
        self.assertEqual(
            self.command.output_options, self.expected_output_options)
    
    def test_executable_string(self):
        """Test that executable path matches expected."""
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.executable_string(quote=False),
                self.expected_executable)
        with self.subTest(msg="quoted"):
            # Note: don't explicitly specify quoted value, because
            # the executable path will vary across different systems.
            self.assertEqual(self.command.executable_string(quote=True),
                ShellCommand.shellquote(self.expected_executable))

def test_argument_string(self):
        """Test that argument string matches expected."""
        args = (self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.argument_string(quote=False),
                " ".join(args))
        with self.subTest(msg="quoted"):
            self.assertEqual(self.command.argument_string(quote=True),
                " ".join([ShellCommand.shellquote(a) for a in args]))

def test_argument_list(self):
        """Test that argument list matches expected."""
        self.assertEqual(self.command.argument_list(),
            self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)

def test_command_string(self):
        """Test that command string matches expected."""
        args = (self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)
        expected_cmd_unquoted = (
            "{exe} {arg}".format(exe=self.expected_executable,
                arg=" ".join(args))
        )
        expected_cmd_quoted = (
            '{exe} {arg}'.format(
                exe=ShellCommand.shellquote(self.expected_executable),
                arg=" ".join([ShellCommand.shellquote(a) for a in args]))
        )
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.command_string(quote=False),
                expected_cmd_unquoted)
        with self.subTest(msg="quoted"):
            self.assertEqual(self.command.command_string(quote=True),
                expected_cmd_quoted)

import unittest

from shell_command import ShellCommand

class ShellCommandSharedTestCase(unittest.TestCase):
    """Shared tests for ShellCommand and its subclasses.
    """

def setUp(self):
        """Initialisation. Make sure the input and output options are
        explicitly set to [] otherwise they hang around from previous
        tests.
        """
        self.command = ShellCommand(input_options=[], output_options=[])
        self.expected_executable = ""
        self.expected_base_options = []
        self.expected_input_options = []
        self.expected_filter_options = []
        self.expected_output_options = []

def tearDown(self):
        """Cleanup.
        """
        self.command = None

def test_base_options(self):
        """Test that base options match expected.
        """
        self.assertEqual(
            self.command._base_options, self.expected_base_options)
    
    def test_input_options(self):
        """Test that input options match expected.
        """
        self.assertEqual(
            self.command.input_options, self.expected_input_options)
    
    def test_output_options(self):
        """Test that output options match expected.
        """
        self.assertEqual(
            self.command.output_options, self.expected_output_options)
    
    def test_executable_string(self):
        """Test that executable path matches expected.
        """
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.executable_string(quote=False),
                self.expected_executable)
        with self.subTest(msg="quoted"):
            # Note: don't explicitly specify quoted value, because
            # the executable path will vary across different systems.
            self.assertEqual(self.command.executable_string(quote=True),
                ShellCommand.shellquote(self.expected_executable))

def test_argument_string(self):
        """Test that the argument string matches expected.
        """
        args = (self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.argument_string(quote=False),
                " ".join(args))
        with self.subTest(msg="quoted"):
            self.assertEqual(self.command.argument_string(quote=True),
                " ".join([ShellCommand.shellquote(a) for a in args]))

def test_argument_list(self):
        """Test that the argument list matches expected.
        """
        self.assertEqual(self.command.argument_list(),
            self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)

def test_command_string(self):
        """Test that the command string matches expected.
        """
        args = (self.expected_base_options + self.expected_input_options +
            self.expected_filter_options + self.expected_output_options)
        expected_cmd_unquoted = (
            "{exe} {arg}".format(exe=self.expected_executable,
                arg=" ".join(args))
        )
        expected_cmd_quoted = (
            '{exe} {arg}'.format(
                exe=ShellCommand.shellquote(self.expected_executable),
                arg=" ".join([ShellCommand.shellquote(a) for a in args]))
        )
        with self.subTest(msg="unquoted"):
            self.assertEqual(self.command.command_string(quote=False),
                expected_cmd_unquoted)
        with self.subTest(msg="quoted"):
            self.assertEqual(self.command.command_string(quote=True),
                expected_cmd_quoted)

Ignore Space Show notes View test_shell_command.py
import unittest from shell_command import ShellCommand from test_shared import ShellCommandSharedTestCase class ShellCommandTestCase(ShellCommandSharedTestCase): """Test the ShellCommand class.""" def setUp(self): """Set up for test.""" # Make sure the input and output options are explicitly set to # [] otherwise they hang around from previous tests. self.command = ShellCommand(input_options=[], output_options=[]) self.expected_executable = "" self.expected_base_options = [] self.expected_input_options = [] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Clean up after test.""" self.command = None def test_shellquote(self): """Test shell quoting (static method).""" with self.subTest(msg="None ⇒ None"): self.assertIsNone(ShellCommand.shellquote(None)) with self.subTest(msg='(empty string) ⇒ (empty string)'): self.assertEqual(ShellCommand.shellquote(""), "") with self.subTest(msg='␢ ⇒ " "'): self.assertEqual(ShellCommand.shellquote(" "), '" "') with self.subTest(msg='␢␢␢␢␢ ⇒ " "'): self.assertEqual(ShellCommand.shellquote(" "), '" "') with self.subTest(msg='foobar ⇒ foobar'): self.assertEqual(ShellCommand.shellquote("foobar"), "foobar") with self.subTest(msg='foo bar ⇒ "foo bar"'): self.assertEqual( ShellCommand.shellquote("foo bar"), '"foo bar"') with self.subTest(msg='"foobar" ⇒ \'"foobar"\''): self.assertEqual( ShellCommand.shellquote('"foobar"'), '\'"foobar"\'') with self.subTest(msg="'foobar' ⇒ 'foobar'"): self.assertEqual( ShellCommand.shellquote("'foobar'"), "'foobar'") with self.subTest(msg="foo 'bar' ⇒ \"foo 'bar'\""): self.assertEqual( ShellCommand.shellquote("foo 'bar'"), '"foo \'bar\'"') with self.subTest(msg='foo"bar ⇒ \'foo"bar\''): self.assertEqual( ShellCommand.shellquote('foo"bar'), '\'foo"bar\'') with self.subTest(msg='foo.bar ⇒ "foo.bar"'): self.assertEqual(ShellCommand.shellquote("foo.bar"), '"foo.bar"') with self.subTest(msg='foo(bar) ⇒ "foo(bar)"'): self.assertEqual( ShellCommand.shellquote("foo(bar)"), '"foo(bar)"') with self.subTest(msg='[foobar] ⇒ "[foobar]"'): self.assertEqual( ShellCommand.shellquote("[foobar]"), '"[foobar]"') with self.subTest(msg='foo[bar ⇒ "foo[bar"'): self.assertEqual(ShellCommand.shellquote("foo[bar"), '"foo[bar"') with self.subTest(msg="/foo/bar ⇒ /foo/bar"): self.assertEqual(ShellCommand.shellquote("/foo/bar"), "/foo/bar") with self.subTest(msg="-f ⇒ -f"): self.assertEqual(ShellCommand.shellquote("-f"), "-f") with self.subTest(msg="-foobar ⇒ -foobar"): self.assertEqual(ShellCommand.shellquote("--foobar"), "--foobar") with self.subTest(msg=r"( ⇒ \("): self.assertEqual(ShellCommand.shellquote("("), r"\(") with self.subTest(msg=r") ⇒ \)"): self.assertEqual(ShellCommand.shellquote(")"), r"\)") # ' => "'" with self.subTest(msg='\' ⇒ "\'"'): self.assertEqual(ShellCommand.shellquote("'"), '"\'"') def test_append_input_options(self): """Test appending to input options.""" with self.subTest(msg="should initially be []"): self.assertEqual(self.command.input_options, []) with self.subTest(msg="appending [] ⇒ []"): self.command.append_input_options([]) self.assertEqual(self.command.input_options, []) with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'): self.command.append_input_options(["foo"]) self.assertEqual(self.command.input_options, ["foo"]) with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'): self.command.append_input_options(["bar"]) self.assertEqual(self.command.input_options, ["foo", "bar"]) with self.subTest( msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'): self.command.append_input_options(["baz", 42]) self.assertEqual( self.command.input_options, ["foo", "bar", "baz", 42]) def test_prepend_input_options(self): """Test prepending to input options.""" with self.subTest(msg="should initially be []"): self.assertEqual(self.command.input_options, []) with self.subTest(msg="prepending [] ⇒ []"): self.command.prepend_input_options([]) self.assertEqual(self.command.input_options, []) with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'): self.command.prepend_input_options(["foo"]) self.assertEqual(self.command.input_options, ["foo"]) with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'): self.command.prepend_input_options(["bar"]) self.assertEqual(self.command.input_options, ["bar", "foo"]) with self.subTest( msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'): self.command.prepend_input_options(["baz", 42]) self.assertEqual( self.command.input_options, ["baz", 42, "bar", "foo"]) def test_append_output_options(self): """Test appending to output options.""" with self.subTest(msg="should initially be []"): self.assertEqual(self.command.output_options, []) with self.subTest(msg="appending [] ⇒ []"): self.command.append_output_options([]) self.assertEqual(self.command.output_options, []) with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'): self.command.append_output_options(["foo"]) self.assertEqual(self.command.output_options, ["foo"]) with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'): self.command.append_output_options(["bar"]) self.assertEqual(self.command.output_options, ["foo", "bar"]) with self.subTest( msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'): self.command.append_output_options(["baz", 42]) self.assertEqual( self.command.output_options, ["foo", "bar", "baz", 42]) def test_prepend_output_options(self): """Test prepending to output options.""" with self.subTest(msg="should initially be []"): self.assertEqual(self.command.output_options, []) with self.subTest(msg="prepending [] ⇒ []"): self.command.prepend_output_options([]) self.assertEqual(self.command.output_options, []) with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'): self.command.prepend_output_options(["foo"]) self.assertEqual(self.command.output_options, ["foo"]) with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'): self.command.prepend_output_options(["bar"]) self.assertEqual(self.command.output_options, ["bar", "foo"]) with self.subTest( msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'): self.command.prepend_output_options(["baz", 42]) self.assertEqual( self.command.output_options, ["baz", 42, "bar", "foo"]) def test_process_pattern(self): """ Test pattern processing.""" # True on EOF (0) with self.subTest(msg="returns True on EOF"): self.assertTrue(self.command.process_pattern(0)) # False on anythingthing else with self.subTest(msg="returns False on 1"): self.assertFalse(self.command.process_pattern(1)) with self.subTest(msg="returns False on -1"): self.assertFalse(self.command.process_pattern(-1)) with self.subTest(msg="returns False on None"): self.assertFalse(self.command.process_pattern(None)) # The following two will require mocking of pexpect? def test_run(self): """Test running of subprocess.""" pass def test_get_output(self): """Test getting output from subprocess.""" pass # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase) import unittest from shell_command import ShellCommand from test_shared import ShellCommandSharedTestCase class ShellCommandTestCase(ShellCommandSharedTestCase): """Test the ShellCommand class. """ def setUp(self): """Initialisation. Make sure the input and output options are explicitly set to [] otherwise they hang around from previous tests. """ self.command = ShellCommand(input_options=[], output_options=[]) self.expected_executable = "" self.expected_base_options = [] self.expected_input_options = [] self.expected_filter_options = [] self.expected_output_options = [] def tearDown(self): """Cleanup. """ self.command = None def test_shellquote(self): """Test static method ShellCommand.shellquote(). """ with self.subTest(msg="None ⇒ None"): self.assertIsNone(ShellCommand.shellquote(None)) with self.subTest(msg='(empty string) ⇒ (empty string)'): self.assertEqual(ShellCommand.shellquote(""), "") with self.subTest(msg='␢ ⇒ " "'): self.assertEqual(ShellCommand.shellquote(" "), '" "') with self.subTest(msg='␢␢␢␢␢ ⇒ " "'): self.assertEqual(ShellCommand.shellquote(" "), '" "') with self.subTest(msg='foobar ⇒ foobar'): self.assertEqual(ShellCommand.shellquote("foobar"), "foobar") with self.subTest(msg='foo bar ⇒ "foo bar"'): self.assertEqual( ShellCommand.shellquote("foo bar"), '"foo bar"') with self.subTest(msg='"foobar" ⇒ \'"foobar"\''): self.assertEqual( ShellCommand.shellquote('"foobar"'), '\'"foobar"\'') with self.subTest(msg="'foobar' ⇒ 'foobar'"): self.assertEqual( ShellCommand.shellquote("'foobar'"), "'foobar'") with self.subTest(msg="foo 'bar' ⇒ \"foo 'bar'\""): self.assertEqual( ShellCommand.shellquote("foo 'bar'"), '"foo \'bar\'"') with self.subTest(msg='foo"bar ⇒ \'foo"bar\''): self.assertEqual( ShellCommand.shellquote('foo"bar'), '\'foo"bar\'') with self.subTest(msg='foo.bar ⇒ "foo.bar"'): self.assertEqual(ShellCommand.shellquote("foo.bar"), '"foo.bar"') with self.subTest(msg='foo(bar) ⇒ "foo(bar)"'): self.assertEqual( ShellCommand.shellquote("foo(bar)"), '"foo(bar)"') with self.subTest(msg='[foobar] ⇒ "[foobar]"'): self.assertEqual( ShellCommand.shellquote("[foobar]"), '"[foobar]"') with self.subTest(msg='foo[bar ⇒ "foo[bar"'): self.assertEqual(ShellCommand.shellquote("foo[bar"), '"foo[bar"') with self.subTest(msg="/foo/bar ⇒ /foo/bar"): self.assertEqual(ShellCommand.shellquote("/foo/bar"), "/foo/bar") with self.subTest(msg="-f ⇒ -f"): self.assertEqual(ShellCommand.shellquote("-f"), "-f") with self.subTest(msg="-foobar ⇒ -foobar"): self.assertEqual(ShellCommand.shellquote("--foobar"), "--foobar") with self.subTest(msg=r"( ⇒ \("): self.assertEqual(ShellCommand.shellquote("("), r"\(") with self.subTest(msg=r") ⇒ \)"): self.assertEqual(ShellCommand.shellquote(")"), r"\)") # ' => "'" with self.subTest(msg='\' ⇒ "\'"'): self.assertEqual(ShellCommand.shellquote("'"), '"\'"') def test_append_input_options(self): """Test method ShellCommand.append_input_options(). """ with self.subTest(msg="should initially be []"): self.assertEqual(self.command.input_options, []) with self.subTest(msg="appending [] ⇒ []"): self.command.append_input_options([]) self.assertEqual(self.command.input_options, []) with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'): self.command.append_input_options(["foo"]) self.assertEqual(self.command.input_options, ["foo"]) with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'): self.command.append_input_options(["bar"]) self.assertEqual(self.command.input_options, ["foo", "bar"]) with self.subTest( msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'): self.command.append_input_options(["baz", 42]) self.assertEqual( self.command.input_options, ["foo", "bar", "baz", 42]) def test_prepend_input_options(self): """Test method ShellCommand.prepend_input_options(). """ with self.subTest(msg="should initially be []"): self.assertEqual(self.command.input_options, []) with self.subTest(msg="prepending [] ⇒ []"): self.command.prepend_input_options([]) self.assertEqual(self.command.input_options, []) with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'): self.command.prepend_input_options(["foo"]) self.assertEqual(self.command.input_options, ["foo"]) with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'): self.command.prepend_input_options(["bar"]) self.assertEqual(self.command.input_options, ["bar", "foo"]) with self.subTest( msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'): self.command.prepend_input_options(["baz", 42]) self.assertEqual( self.command.input_options, ["baz", 42, "bar", "foo"]) def test_append_output_options(self): """Test method ShellCommand.append_output_options(). """ with self.subTest(msg="should initially be []"): self.assertEqual(self.command.output_options, []) with self.subTest(msg="appending [] ⇒ []"): self.command.append_output_options([]) self.assertEqual(self.command.output_options, []) with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'): self.command.append_output_options(["foo"]) self.assertEqual(self.command.output_options, ["foo"]) with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'): self.command.append_output_options(["bar"]) self.assertEqual(self.command.output_options, ["foo", "bar"]) with self.subTest( msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'): self.command.append_output_options(["baz", 42]) self.assertEqual( self.command.output_options, ["foo", "bar", "baz", 42]) def test_prepend_output_options(self): """Test method ShellCommand.prepend_output_options. """ with self.subTest(msg="should initially be []"): self.assertEqual(self.command.output_options, []) with self.subTest(msg="prepending [] ⇒ []"): self.command.prepend_output_options([]) self.assertEqual(self.command.output_options, []) with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'): self.command.prepend_output_options(["foo"]) self.assertEqual(self.command.output_options, ["foo"]) with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'): self.command.prepend_output_options(["bar"]) self.assertEqual(self.command.output_options, ["bar", "foo"]) with self.subTest( msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'): self.command.prepend_output_options(["baz", 42]) self.assertEqual( self.command.output_options, ["baz", 42, "bar", "foo"]) def test_process_pattern(self): """ Test method ShellCommand.process_pattern(). """ # True on EOF (0) with self.subTest(msg="returns True on EOF"): self.assertTrue(self.command.process_pattern(0)) # False on anythingthing else with self.subTest(msg="returns False on 1"): self.assertFalse(self.command.process_pattern(1)) with self.subTest(msg="returns False on -1"): self.assertFalse(self.command.process_pattern(-1)) with self.subTest(msg="returns False on None"): self.assertFalse(self.command.process_pattern(None)) # The following two will require mocking of pexpect? def test_run(self): """Test method ShellCommand.run(). """ pass def test_get_output(self): """Test method ShellCommand.get_output(). """ pass # Remove ShellCommandSharedTestCase from the namespace so we don't run # the shared tests twice. See <https://stackoverflow.com/a/22836015>. del(ShellCommandSharedTestCase)

Ignore Space Show notes View

test_shell_command.py

import unittest

from shell_command import ShellCommand
from test_shared import ShellCommandSharedTestCase

class ShellCommandTestCase(ShellCommandSharedTestCase):
    """Test the ShellCommand class."""

def tearDown(self):
        """Clean up after test."""
        self.command = None

def test_shellquote(self):
        """Test shell quoting (static method)."""
        with self.subTest(msg="None ⇒ None"):
            self.assertIsNone(ShellCommand.shellquote(None))
        with self.subTest(msg='(empty string) ⇒ (empty string)'):
            self.assertEqual(ShellCommand.shellquote(""), "")
        with self.subTest(msg='␢ ⇒ " "'):
            self.assertEqual(ShellCommand.shellquote(" "), '" "')
        with self.subTest(msg='␢␢␢␢␢ ⇒ "     "'):
            self.assertEqual(ShellCommand.shellquote("     "), '"     "')
        with self.subTest(msg='foobar ⇒ foobar'):
            self.assertEqual(ShellCommand.shellquote("foobar"), "foobar")
        with self.subTest(msg='foo bar ⇒ "foo bar"'):
            self.assertEqual(
                ShellCommand.shellquote("foo bar"), '"foo bar"')
        with self.subTest(msg='"foobar" ⇒ \'"foobar"\''):
            self.assertEqual(
                ShellCommand.shellquote('"foobar"'), '\'"foobar"\'')
        with self.subTest(msg="'foobar' ⇒ 'foobar'"):
            self.assertEqual(
                ShellCommand.shellquote("'foobar'"), "'foobar'")
        with self.subTest(msg="foo 'bar' ⇒ \"foo 'bar'\""):
            self.assertEqual(
                ShellCommand.shellquote("foo 'bar'"), '"foo \'bar\'"')
        with self.subTest(msg='foo"bar ⇒ \'foo"bar\''):
            self.assertEqual(
                ShellCommand.shellquote('foo"bar'), '\'foo"bar\'')
        with self.subTest(msg='foo.bar ⇒ "foo.bar"'):
            self.assertEqual(ShellCommand.shellquote("foo.bar"), '"foo.bar"')
        with self.subTest(msg='foo(bar) ⇒ "foo(bar)"'):
            self.assertEqual(
                ShellCommand.shellquote("foo(bar)"), '"foo(bar)"')
        with self.subTest(msg='[foobar] ⇒ "[foobar]"'):
            self.assertEqual(
                ShellCommand.shellquote("[foobar]"), '"[foobar]"')
        with self.subTest(msg='foo[bar ⇒ "foo[bar"'):
            self.assertEqual(ShellCommand.shellquote("foo[bar"), '"foo[bar"')
        with self.subTest(msg="/foo/bar ⇒ /foo/bar"):
            self.assertEqual(ShellCommand.shellquote("/foo/bar"), "/foo/bar")
        with self.subTest(msg="-f ⇒ -f"):
            self.assertEqual(ShellCommand.shellquote("-f"), "-f")
        with self.subTest(msg="-foobar ⇒ -foobar"):
            self.assertEqual(ShellCommand.shellquote("--foobar"), "--foobar")
        with self.subTest(msg=r"( ⇒ \("):
            self.assertEqual(ShellCommand.shellquote("("), r"\(")
        with self.subTest(msg=r") ⇒ \)"):
            self.assertEqual(ShellCommand.shellquote(")"), r"\)")
        # ' => "'"
        with self.subTest(msg='\' ⇒ "\'"'):
            self.assertEqual(ShellCommand.shellquote("'"), '"\'"')

def test_append_input_options(self):
        """Test appending to input options."""
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg="appending [] ⇒ []"):
            self.command.append_input_options([])
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'):
            self.command.append_input_options(["foo"])
            self.assertEqual(self.command.input_options, ["foo"])
        with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'):
            self.command.append_input_options(["bar"])
            self.assertEqual(self.command.input_options, ["foo", "bar"])
        with self.subTest(
                msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'):
            self.command.append_input_options(["baz", 42])
            self.assertEqual(
                self.command.input_options, ["foo", "bar", "baz", 42])

def test_prepend_input_options(self):
        """Test prepending to input options."""
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg="prepending [] ⇒ []"):
            self.command.prepend_input_options([])
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'):
            self.command.prepend_input_options(["foo"])
            self.assertEqual(self.command.input_options, ["foo"])
        with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'):
            self.command.prepend_input_options(["bar"])
            self.assertEqual(self.command.input_options, ["bar", "foo"])
        with self.subTest(
                msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'):
            self.command.prepend_input_options(["baz", 42])
            self.assertEqual(
                self.command.input_options, ["baz", 42, "bar", "foo"])

def test_append_output_options(self):
        """Test appending to output options."""
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg="appending [] ⇒ []"):
            self.command.append_output_options([])
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'):
            self.command.append_output_options(["foo"])
            self.assertEqual(self.command.output_options, ["foo"])
        with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'):
            self.command.append_output_options(["bar"])
            self.assertEqual(self.command.output_options, ["foo", "bar"])
        with self.subTest(
                msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'):
            self.command.append_output_options(["baz", 42])
            self.assertEqual(
                self.command.output_options, ["foo", "bar", "baz", 42])

def test_prepend_output_options(self):
        """Test prepending to output options."""
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg="prepending [] ⇒ []"):
            self.command.prepend_output_options([])
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'):
            self.command.prepend_output_options(["foo"])
            self.assertEqual(self.command.output_options, ["foo"])
        with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'):
            self.command.prepend_output_options(["bar"])
            self.assertEqual(self.command.output_options, ["bar", "foo"])
        with self.subTest(
                msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'):
            self.command.prepend_output_options(["baz", 42])
            self.assertEqual(
                self.command.output_options, ["baz", 42, "bar", "foo"])

def test_process_pattern(self):
        """ Test pattern processing."""
        # True on EOF (0)
        with self.subTest(msg="returns True on EOF"):
            self.assertTrue(self.command.process_pattern(0))
        # False on anythingthing else
        with self.subTest(msg="returns False on 1"):
            self.assertFalse(self.command.process_pattern(1))
        with self.subTest(msg="returns False on -1"):
            self.assertFalse(self.command.process_pattern(-1))
        with self.subTest(msg="returns False on None"):
            self.assertFalse(self.command.process_pattern(None))

# The following two will require mocking of pexpect?
    def test_run(self):
        """Test running of subprocess."""
        pass

def test_get_output(self):
        """Test getting output from subprocess."""
        pass

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

import unittest

from shell_command import ShellCommand
from test_shared import ShellCommandSharedTestCase

class ShellCommandTestCase(ShellCommandSharedTestCase):
    """Test the ShellCommand class.
    """

def tearDown(self):
        """Cleanup.
        """
        self.command = None

def test_shellquote(self):
        """Test static method ShellCommand.shellquote().
        """
        with self.subTest(msg="None ⇒ None"):
            self.assertIsNone(ShellCommand.shellquote(None))
        with self.subTest(msg='(empty string) ⇒ (empty string)'):
            self.assertEqual(ShellCommand.shellquote(""), "")
        with self.subTest(msg='␢ ⇒ " "'):
            self.assertEqual(ShellCommand.shellquote(" "), '" "')
        with self.subTest(msg='␢␢␢␢␢ ⇒ "     "'):
            self.assertEqual(ShellCommand.shellquote("     "), '"     "')
        with self.subTest(msg='foobar ⇒ foobar'):
            self.assertEqual(ShellCommand.shellquote("foobar"), "foobar")
        with self.subTest(msg='foo bar ⇒ "foo bar"'):
            self.assertEqual(
                ShellCommand.shellquote("foo bar"), '"foo bar"')
        with self.subTest(msg='"foobar" ⇒ \'"foobar"\''):
            self.assertEqual(
                ShellCommand.shellquote('"foobar"'), '\'"foobar"\'')
        with self.subTest(msg="'foobar' ⇒ 'foobar'"):
            self.assertEqual(
                ShellCommand.shellquote("'foobar'"), "'foobar'")
        with self.subTest(msg="foo 'bar' ⇒ \"foo 'bar'\""):
            self.assertEqual(
                ShellCommand.shellquote("foo 'bar'"), '"foo \'bar\'"')
        with self.subTest(msg='foo"bar ⇒ \'foo"bar\''):
            self.assertEqual(
                ShellCommand.shellquote('foo"bar'), '\'foo"bar\'')
        with self.subTest(msg='foo.bar ⇒ "foo.bar"'):
            self.assertEqual(ShellCommand.shellquote("foo.bar"), '"foo.bar"')
        with self.subTest(msg='foo(bar) ⇒ "foo(bar)"'):
            self.assertEqual(
                ShellCommand.shellquote("foo(bar)"), '"foo(bar)"')
        with self.subTest(msg='[foobar] ⇒ "[foobar]"'):
            self.assertEqual(
                ShellCommand.shellquote("[foobar]"), '"[foobar]"')
        with self.subTest(msg='foo[bar ⇒ "foo[bar"'):
            self.assertEqual(ShellCommand.shellquote("foo[bar"), '"foo[bar"')
        with self.subTest(msg="/foo/bar ⇒ /foo/bar"):
            self.assertEqual(ShellCommand.shellquote("/foo/bar"), "/foo/bar")
        with self.subTest(msg="-f ⇒ -f"):
            self.assertEqual(ShellCommand.shellquote("-f"), "-f")
        with self.subTest(msg="-foobar ⇒ -foobar"):
            self.assertEqual(ShellCommand.shellquote("--foobar"), "--foobar")
        with self.subTest(msg=r"( ⇒ \("):
            self.assertEqual(ShellCommand.shellquote("("), r"\(")
        with self.subTest(msg=r") ⇒ \)"):
            self.assertEqual(ShellCommand.shellquote(")"), r"\)")
        # ' => "'"
        with self.subTest(msg='\' ⇒ "\'"'):
            self.assertEqual(ShellCommand.shellquote("'"), '"\'"')

def test_append_input_options(self):
        """Test method ShellCommand.append_input_options().
        """
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg="appending [] ⇒ []"):
            self.command.append_input_options([])
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'):
            self.command.append_input_options(["foo"])
            self.assertEqual(self.command.input_options, ["foo"])
        with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'):
            self.command.append_input_options(["bar"])
            self.assertEqual(self.command.input_options, ["foo", "bar"])
        with self.subTest(
                msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'):
            self.command.append_input_options(["baz", 42])
            self.assertEqual(
                self.command.input_options, ["foo", "bar", "baz", 42])

def test_prepend_input_options(self):
        """Test method ShellCommand.prepend_input_options().
        """
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg="prepending [] ⇒ []"):
            self.command.prepend_input_options([])
            self.assertEqual(self.command.input_options, [])
        with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'):
            self.command.prepend_input_options(["foo"])
            self.assertEqual(self.command.input_options, ["foo"])
        with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'):
            self.command.prepend_input_options(["bar"])
            self.assertEqual(self.command.input_options, ["bar", "foo"])
        with self.subTest(
                msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'):
            self.command.prepend_input_options(["baz", 42])
            self.assertEqual(
                self.command.input_options, ["baz", 42, "bar", "foo"])

def test_append_output_options(self):
        """Test method ShellCommand.append_output_options().
        """
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg="appending [] ⇒ []"):
            self.command.append_output_options([])
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg='appending ["foo"] ⇒ ["foo"]'):
            self.command.append_output_options(["foo"])
            self.assertEqual(self.command.output_options, ["foo"])
        with self.subTest(msg='appending ["bar"] ⇒ ["foo", "bar"]'):
            self.command.append_output_options(["bar"])
            self.assertEqual(self.command.output_options, ["foo", "bar"])
        with self.subTest(
                msg='appending ["baz", 42] ⇒ ["foo", "bar", "baz", 42]'):
            self.command.append_output_options(["baz", 42])
            self.assertEqual(
                self.command.output_options, ["foo", "bar", "baz", 42])

def test_prepend_output_options(self):
        """Test method ShellCommand.prepend_output_options.
        """
        with self.subTest(msg="should initially be []"):
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg="prepending [] ⇒ []"):
            self.command.prepend_output_options([])
            self.assertEqual(self.command.output_options, [])
        with self.subTest(msg='prepending ["foo"] ⇒ ["foo"]'):
            self.command.prepend_output_options(["foo"])
            self.assertEqual(self.command.output_options, ["foo"])
        with self.subTest(msg='prepending ["bar"] ⇒ ["bar", "foo"]'):
            self.command.prepend_output_options(["bar"])
            self.assertEqual(self.command.output_options, ["bar", "foo"])
        with self.subTest(
                msg='prepending ["baz", 42] ⇒ ["baz", 42, "bar", "foo]'):
            self.command.prepend_output_options(["baz", 42])
            self.assertEqual(
                self.command.output_options, ["baz", 42, "bar", "foo"])

def test_process_pattern(self):
        """ Test method ShellCommand.process_pattern().
        """
        # True on EOF (0)
        with self.subTest(msg="returns True on EOF"):
            self.assertTrue(self.command.process_pattern(0))
        # False on anythingthing else
        with self.subTest(msg="returns False on 1"):
            self.assertFalse(self.command.process_pattern(1))
        with self.subTest(msg="returns False on -1"):
            self.assertFalse(self.command.process_pattern(-1))
        with self.subTest(msg="returns False on None"):
            self.assertFalse(self.command.process_pattern(None))

# The following two will require mocking of pexpect?
    def test_run(self):
        """Test method ShellCommand.run().
        """
        pass

def test_get_output(self):
        """Test method ShellCommand.get_output().
        """
        pass

# Remove ShellCommandSharedTestCase from the namespace so we don't run
# the shared tests twice. See <https://stackoverflow.com/a/22836015>.
del(ShellCommandSharedTestCase)

Show line notes below