Merge lp:~vila/bzr/shell-like-tests-borked into lp:~bzr/bzr/trunk-old

[Vincent Ladeuil]

[Vincent Ladeuil (vila)]

This implement a new TestCase that provides the ability to run shell-like scenarios like:

class TestConflict(script.TestCaseWithScript):

    def test_content_conflict(self):
        story = """
bzr init trunk
cd trunk
echo "trunk content" >file
bzr add file
bzr commit -m 'Create trunk'
bzr branch . ../branch
cd ../branch
bzr rm file
bzr commit -m 'Delete file'
cd ../trunk
echo "more content" >>file
bzr commit -m 'Modify file'
cd ../branch
bzr merge ../trunk
"""
        self.run_script(story)
        wt, relpath = workingtree.WorkingTree.open_containing('branch')
        self.assertEqual(1, len(wt.conflicts()))

Commands implemented: bzr (ha ha), cat, echo, cd, mkdir.

cd and mkdir are jailed.
Redirections are handled for echo and cat (<, >, >>).

More can be done but I think that implementation is already usable and I don't want to
add too much features without getting some feedback first.

[John A Meinel (jameinel)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Vincent Ladeuil wrote:
> Vincent Ladeuil has proposed merging lp:~vila/bzr/shell-like-tests into lp:bzr.
>
> Requested reviews:
> bzr-core (bzr-core)
>
> This implement a new TestCase that provides the ability to run shell-like scenarios like:
>
> class TestConflict(script.TestCaseWithScript):
>
> def test_content_conflict(self):
> story = """
> bzr init trunk
> cd trunk
> echo "trunk content" >file
> bzr add file
> bzr commit -m 'Create trunk'
> bzr branch . ../branch
> cd ../branch
> bzr rm file
> bzr commit -m 'Delete file'
> cd ../trunk
> echo "more content" >>file
> bzr commit -m 'Modify file'
> cd ../branch
> bzr merge ../trunk
> """
> self.run_script(story)
> wt, relpath = workingtree.WorkingTree.open_containing('branch')
> self.assertEqual(1, len(wt.conflicts()))
>
> Commands implemented: bzr (ha ha), cat, echo, cd, mkdir.
>
> cd and mkdir are jailed.
> Redirections are handled for echo and cat (<, >, >>).
>
> More can be done but I think that implementation is already usable and I don't want to
> add too much features without getting some feedback first.

 review: needs_information

1) My first concern is that the above doesn't provide a way to do any
assertions. It just provides a way to run a bunch of commands.

If you look at how doctest does it, it does:

>>> command_to_run()
output

We could do something similar with:
$ command_to_run()
output

Though we then don't have a way to declare a different between stdout
and stderr. Nor do we have a way to say that this command should succeed
cleanly, or this command should fail in a particular way.

Because of that, it means that the shell scripting really only works as
a way to *set up* a test case. Which is arguably where we should be
spending the least amount of time, not the bulk of the time as we work
in 'command' level rather than internal object level.

Maybe the overhead isn't as big as it once was, because we don't spawn
anymore. But given Robert's recent threads about wanting to *speed up*
selftest, this doesn't seem to be going in the right direction.

2)

+class TestCaseWithScript(tests.TestCaseWithTransport):
...
+ def do_bzr(self, input, args):
...
+ def do_cat(self, input, args):
...

It feels to me like things such as "do_bzr" should be part of a helper
class, not part of the TestCase itself.

So something more like:

class ScriptClass(object):

  def __init__(self, actions_str):
    # parse and build up a list of actions

  def run(self):
    ...

  def do_bzr(...)
  def do_cat(...)
  def do_echo(...)

class TestCaseWithScript(tests.TestCaseWithTransport):

  _script_class = ScriptClass

  def run_script(self, actions):
    script = self._script_class(actions)
    script.run() # Should we pass the TestCase (self) in?

By making _script_class a member variable, test cases that want to
override behavior can do so by subclassing ScriptClass rather than
directly overriding self.do_foo()

3) I think the functionality is well tested. My biggest concerns are how
is this actually going to benefit us.

John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Com...

review: Needs Information

[Vincent Ladeuil (vila)]

>>>>> "jam" == John A Meinel writes:

<snip/>

    jam> 1) My first concern is that the above doesn't provide a
    jam> way to do any assertions. It just provides a way to run
    jam> a bunch of commands.

No. You can provide input, expected stdout and expected stderr:

bzr init
cat >file
<content
bzr add file
>adding file
bzr add foo
2>bzr: ERROR: No such file: u'foo'

Well, ok, I slightly lied for the last one because bzr output an
abspath and that's a bit hard to embed (still doable but
unpractical).

<snip/>

    jam> Though we then don't have a way to declare a different
    jam> between stdout and stderr.

Yes we have. I didn't distinguish between stdout and stderr at
first, but then, I realized that it will make things more
complicated.

So the feature here is that if you specify a content for stdout
or stderr, you want it to match exactly.

I feel that strict matching is a bit restrictive (as shown above
already), but I'm not yet sold to regexps there (and how), I'd
like more use cases before.

    jam> Nor do we have a way to say that this command should
    jam> succeed cleanly, or this command should fail in a
    jam> particular way.

The idea is that a script should "succeed" as described,
i.e. match the expected std[out|err] if specified for each
command.

This may not be tested correctly yet but see
test_unexpected_output.

<snip/>

    jam> Maybe the overhead isn't as big as it once was, because
    jam> we don't spawn anymore. But given Robert's recent
    jam> threads about wanting to *speed up* selftest, this
    jam> doesn't seem to be going in the right direction.

The intent is not to have faster tests but to allow more people
to write tests.

Once the tests are written that way, we can rewrite them in more
optimal ways, the bug or desired feature has been captured,
that's the goal.

And the original writers can even look at the rewritten form and
learn quicker since they know what the test is supposed to do in
its first form.

    jam> 2)

    jam> +class TestCaseWithScript(tests.TestCaseWithTransport):
    jam> ...
    jam> + def do_bzr(self, input, args):
    jam> ...
    jam> + def do_cat(self, input, args):
    jam> ...

    jam> It feels to me like things such as "do_bzr" should be part of a helper
    jam> class, not part of the TestCase itself.

That doesn't fly for jailed commands, so I didn't try.

<snip/>

    jam> By making _script_class a member variable, test cases
    jam> that want to override behavior can do so by subclassing
    jam> ScriptClass rather than directly overriding

Use cases for overriding ?

And don't forget that we can run several scripts in the same test
like we do with run_bzr().

<snip/>

    jam> 3) I think the functionality is well tested.
    jam> My biggest concerns are how is this actually going to
    jam> benefit us.

I hope I clarified things a bit.

[Martin Pool (mbp)]

2009/9/2 Vincent Ladeuil <email address hidden>:

Thanks for doing this, you beat me to it.

I haven't read the patch itself yet, but I am keen to see some
experiments in this direction.

> <snip/>
>
>    jam> 1) My first concern is that the above doesn't provide a
>    jam> way to do any assertions. It just provides a way to run
>    jam> a bunch of commands.
>
> No. You can provide input, expected stdout and expected stderr:
>
> bzr init
> cat >file
> <content
> bzr add file
>>adding file
> bzr add foo
> 2>bzr: ERROR: No such file: u'foo'

Maybe this is a hole in the documentation then, if jam didn't notice it?

>
> Well, ok, I slightly lied for the last one because bzr output an
> abspath and that's a bit hard to embed (still doable but
> unpractical).

(Also a bug that we have the unicode prefix.)

Perhaps it should eventually pretend that everything is being run in eg /test/

>
> <snip/>
>
>    jam> Though we then don't have a way to declare a different
>    jam> between stdout and stderr.
>
> Yes we have. I didn't distinguish between stdout and stderr at
> first, but then, I realized that it will make things more
> complicated.
>
> So the feature here is that if you specify a content for stdout
> or stderr, you want it to match exactly.
>
> I feel that strict matching is a bit restrictive (as shown above
> already), but I'm not yet sold to regexps there (and how), I'd
> like more use cases before.

Robert said that the loose matching in doctest can be separated out.

>    jam> Nor do we have a way to say that this command should
>    jam> succeed cleanly, or this command should fail in a
>    jam> particular way.
>
> The idea is that a script should "succeed" as described,
> i.e. match the expected std[out|err] if specified for each
> command.
>
> This may not be tested correctly yet but see
> test_unexpected_output.

You could make it pretend it's being run under a shell that prints a
message if it exits with a non-zero status, as bash and zsh can be
configured to do.

>    jam> Maybe the overhead isn't as big as it once was, because
>    jam> we don't spawn anymore. But given Robert's recent
>    jam> threads about wanting to *speed up* selftest, this
>    jam> doesn't seem to be going in the right direction.
>
> The intent is not to have faster tests but to allow more people
> to write tests.
>
> Once the tests are written that way, we can rewrite them in more
> optimal ways, the bug or desired feature has been captured,
> that's the goal.
>
> And the original writers can even look at the rewritten form and
> learn quicker since they know what the test is supposed to do in
> its first form.

I think that's a valid goal, and will lower a barrier to contribution,
but not ultimately where we want to end up. It could go wrong like
this: people who can only read the easy tests can't add new tests in
modules written in the old style, and eventually can't even read the
tests they previously wrote themselves.

I don't think we want a style of writing tests that the core
developers never use, because it will rot: so this needs to be
competitively fast and easy to use effectively, at least for some
category of tests.

But I think that's quite...

=== modified file 'bzrlib/tests/__init__.py'
--- bzrlib/tests/__init__.py	2009-08-28 21:05:31 +0000
+++ bzrlib/tests/__init__.py	2009-09-01 16:35:10 +0000
@@ -3618,6 +3618,7 @@
         'bzrlib.tests.test_rio',
         'bzrlib.tests.test_rules',
         'bzrlib.tests.test_sampler',
+        'bzrlib.tests.test_script',
         'bzrlib.tests.test_selftest',
         'bzrlib.tests.test_serializer',
         'bzrlib.tests.test_setup',

=== added file 'bzrlib/tests/script.py'
--- bzrlib/tests/script.py	1970-01-01 00:00:00 +0000
+++ bzrlib/tests/script.py	2009-09-01 16:35:10 +0000
@@ -0,0 +1,256 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+from cStringIO import StringIO
+import os
+import shlex
+
+from bzrlib import (
+    osutils,
+    tests,
+    )
+
+
+def split(s):
+    """Split a command line respecting quotes."""
+    scanner = shlex.shlex(s)
+    scanner.quotes = '\'"`'
+    scanner.whitespace_split = True
+    for t in list(scanner):
+        # Strip the simple and double quotes since we don't care about them.
+        # We leave the backquotes in place though since they have a different
+        # semantic.
+        if t[0] in  ('"', "'") and t[0] == t[-1]:
+            yield t[1:-1]
+        else:
+            yield t
+
+
+def _script_to_commands(text, file_name=None):
+    """Turn a script into a list of commands with their associated IOs.
+
+    Each command appears on a line by itself. It can be associated with an
+    input that will feed it and an expected output.
+    Comments starts with '#' until the end of line.
+    Empty lines are ignored.
+    Input and output are full lines terminated by a '\n'.
+    Input lines start with '<'.
+    Output lines start with '>'.
+    Error lines start with '2>'.
+    """
+
+    commands = []
+
+    def add_command(cmd, input, output, error):
+        if cmd is not None:
+            if input is not None:
+                input = ''.join(input)
+            if output is not None:
+                output = ''.join(output)
+            if error is not None:
+                error = ''.join(error)
+            commands.append((cmd, input, output, error))
+
+    cmd_cur = None
+    cmd_line = 1
+    lineno = 0
+    input, output, error = None, None, None
+    for line in text.split('\n'):
+        lineno += 1
+        # Keep a copy for error reporting
+        orig = line
+        comment =  line.find('#')
+        if comment >= 0:
+            # Delete comments
+            line = line[0:comment]
+            line = line.rstrip()
+        if line == '':
+            # Ignore empty lines
+            continue
+        if line.startswith('<'):
+            if input is None:
+                if cmd_cur is None:
+                    raise SyntaxError('No command for that input',
+                                      (file_name, lineno, 1, orig))
+                input = []
+            input.append(line[1:] + '\n')
+            continue
+        elif line.startswith('>'):
+            if output is None:
+                if cmd_cur is None:
+                    raise SyntaxError('No command for that output',
+                                      (file_name, lineno, 1, orig))
+                output = []
+            output.append(line[1:] + '\n')
+            continue
+        elif line.startswith('2>'):
+            if error is None:
+                if cmd_cur is None:
+                    raise SyntaxError('No command for that error',
+                                      (file_name, lineno, 1, orig))
+                error = []
+            error.append(line[2:] + '\n')
+            continue
+        else:
+            # Time to output the current command
+            add_command(cmd_cur, input, output, error)
+            # And start a new one
+            cmd_cur = list(split(line))
+            cmd_line = lineno
+            input, output, error = None, None, None
+    # Add the last seen command
+    add_command(cmd_cur, input, output, error)
+    return commands
+
+
+def _scan_redirection_options(args):
+    """Recognize and process input and output redirections.
+
+    :param args: The command line arguments
+
+    :return: A tuple containing: 
+        - The file name redirected from or None
+        - The file name redirected to or None
+        - The mode to open the output file or None
+        - The reamining arguments
+    """
+    remaining = []
+    in_name = None
+    out_name, out_mode = None, None
+    for arg in  args:
+        if arg.startswith('<'):
+            in_name = arg[1:]
+        elif arg.startswith('>>'):
+            out_name = arg[2:]
+            out_mode = 'ab+'
+        elif arg.startswith('>'):
+            out_name = arg[1:]
+            out_mode = 'wb+'
+        else:
+            remaining.append(arg)
+    return in_name, out_name, out_mode, remaining
+
+
+class TestCaseWithScript(tests.TestCaseWithTransport):
+
+    def setUp(self):
+        super(TestCaseWithScript, self).setUp()
+        self._vars = {}
+
+    def run_script(self, text):
+        for cmd, input, output, error in _script_to_commands(text):
+            self.run_command(cmd, input, output, error)
+
+    def _check_output(self, expected, actual):
+        if expected is None:
+            # Specifying None means: any output is accepted
+            return
+        self.assertEquals(expected, actual)
+
+    def run_command(self, cmd, input, output, error):
+        mname = 'do_' + cmd[0]
+        method = getattr(self, mname, None)
+        if method is None:
+            raise SyntaxError('Command not found "%s"' % (cmd[0],),
+                              None, 1, ' '.join(cmd))
+        if input is None:
+            str_input = ''
+        else:
+            str_input = ''.join(input)
+        actual_output, actual_error = method(str_input, cmd[1:])
+
+        self._check_output(output, actual_output)
+        self._check_output(error, actual_error)
+        return actual_output, actual_error
+
+    def _read_input(self, input, in_name):
+        if in_name is not None:
+            infile = open(in_name, 'rb')
+            try:
+                # Command redirection takes precedence over provided input
+                input = infile.read()
+            finally:
+                infile.close()
+        return input
+
+    def _write_output(self, output, out_name, out_mode):
+        if out_name is not None:
+            outfile = open(out_name, out_mode)
+            try:
+                outfile.write(output)
+            finally:
+                outfile.close()
+            output = None
+        return output
+
+    def do_bzr(self, input, args):
+        out, err = self._run_bzr_core(args, retcode=None, encoding=None,
+                                      stdin=input, working_dir=None)
+        return out, err
+
+    def do_cat(self, input, args):
+        (in_name, out_name, out_mode, args) = _scan_redirection_options(args)
+        if len(args) > 1:
+            raise SyntaxError('Usage: cat [file1]')
+        if args:
+            if in_name is not None:
+                raise SyntaxError('Specify a file OR use redirection')
+            in_name = args[0]
+        input = self._read_input(input, in_name)
+        # Basically cat copy input to output
+        output = input
+        # Handle output redirections
+        output = self._write_output(output, out_name, out_mode)
+        return output, None
+
+    def do_echo(self, input, args):
+        (in_name, out_name, out_mode, args) = _scan_redirection_options(args)
+        if input and args:
+                raise SyntaxError('Specify parameters OR use redirection')
+        if args:
+            input = ''.join(args)
+        input = self._read_input(input, in_name)
+        # Always append a \n'
+        input += '\n'
+        # Process output
+        output = input
+        # Handle output redirections
+        output = self._write_output(output, out_name, out_mode)
+        return output, None
+
+    def _ensure_in_jail(self, path):
+        if not osutils.is_inside(self.test_dir, osutils.normalizepath(path)):
+                raise ValueError('%s is not inside %s' % (path, self.test_dir))
+
+    def do_cd(self, input, args):
+        if len(args) > 1:
+            raise SyntaxError('Usage: cd [dir]')
+        if len(args) == 1:
+            d = args[0]
+            self._ensure_in_jail(d)
+        else:
+            d = self.test_dir
+        os.chdir(d)
+        return None, None
+
+    def do_mkdir(self, input, args):
+        if not args or len(args) != 1:
+            raise SyntaxError('Usage: mkdir dir')
+        d = args[0]
+        self._ensure_in_jail(d)
+        os.mkdir(d)
+        return None, None
+

=== added file 'bzrlib/tests/test_script.py'
--- bzrlib/tests/test_script.py	1970-01-01 00:00:00 +0000
+++ bzrlib/tests/test_script.py	2009-09-01 16:35:10 +0000
@@ -0,0 +1,218 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+from bzrlib import (
+    osutils,
+    tests,
+    )
+from bzrlib.tests import script
+
+
+class TestScriptSyntax(tests.TestCase):
+
+    def test_comment_is_ignored(self):
+        self.assertEquals([], script._script_to_commands('#comment\n'))
+
+    def test_empty_line_is_ignored(self):
+        self.assertEquals([], script._script_to_commands('\n'))
+
+    def test_simple_command(self):
+        self.assertEquals([(['cd', 'trunk'], None, None, None)],
+                           script._script_to_commands('cd trunk'))
+
+    def test_command_with_single_quoted_param(self):
+        story = """bzr commit -m 'two words'"""
+        self.assertEquals([(['bzr', 'commit', '-m', 'two words'],
+                            None, None, None)],
+                           script._script_to_commands(story))
+
+    def test_command_with_double_quoted_param(self):
+        story = """bzr commit -m "two words" """
+        self.assertEquals([(['bzr', 'commit', '-m', 'two words'],
+                            None, None, None)],
+                           script._script_to_commands(story))
+
+    def test_command_with_input(self):
+        self.assertEquals([(['cat', '>file'], 'content\n', None, None)],
+                           script._script_to_commands('cat >file\n<content\n'))
+
+    def test_command_with_output(self):
+        story = """
+bzr add
+>adding file
+>adding file2
+"""
+        self.assertEquals([(['bzr', 'add'], None,
+                            'adding file\nadding file2\n', None)],
+                          script._script_to_commands(story))
+
+    def test_command_with_error(self):
+        story = """
+bzr branch foo
+2>bzr: ERROR: Not a branch: "foo"
+"""
+        self.assertEquals([(['bzr', 'branch', 'foo'],
+                            None, None, 'bzr: ERROR: Not a branch: "foo"\n')],
+                          script._script_to_commands(story))
+    def test_input_without_command(self):
+        self.assertRaises(SyntaxError, script._script_to_commands, '<input')
+
+    def test_output_without_command(self):
+        self.assertRaises(SyntaxError, script._script_to_commands, '>input')
+
+    def test_command_with_backquotes(self):
+        story = """
+foo = `bzr file-id toto`
+"""
+        self.assertEquals([(['foo', '=', '`bzr file-id toto`'],
+                            None, None, None)],
+                          script._script_to_commands(story))
+
+
+class TestScriptExecution(script.TestCaseWithScript):
+
+    def test_unknown_command(self):
+        self.assertRaises(SyntaxError, self.run_script, 'foo')
+
+    def test_unexpected_output(self):
+        story = """
+mkdir dir
+cd dir
+>Hello, I have just cd into dir !
+"""
+        self.assertRaises(AssertionError, self.run_script, story)
+
+
+class TestCat(script.TestCaseWithScript):
+
+    def test_cat_usage(self):
+        self.assertRaises(SyntaxError, self.run_script, 'cat foo bar baz')
+        self.assertRaises(SyntaxError, self.run_script, 'cat foo <bar')
+
+    def test_cat_input_to_output(self):
+        out, err = self.run_command(['cat'], 'content\n', 'content\n', None)
+        self.assertEquals('content\n', out)
+        self.assertEquals(None, err)
+
+    def test_cat_file_to_output(self):
+        self.build_tree_contents([('file', 'content\n')])
+        out, err = self.run_command(['cat', 'file'], None, 'content\n', None)
+        self.assertEquals('content\n', out)
+        self.assertEquals(None, err)
+
+    def test_cat_input_to_file(self):
+        out, err = self.run_command(['cat', '>file'], 'content\n', None, None)
+        self.assertFileEqual('content\n', 'file')
+        self.assertEquals(None, out)
+        self.assertEquals(None, err)
+        out, err = self.run_command(['cat', '>>file'], 'more\n', None, None)
+        self.assertFileEqual('content\nmore\n', 'file')
+        self.assertEquals(None, out)
+        self.assertEquals(None, err)
+
+    def test_cat_file_to_file(self):
+        self.build_tree_contents([('file', 'content\n')])
+        out, err = self.run_command(['cat', 'file', '>file2'], None, None, None)
+        self.assertFileEqual('content\n', 'file2')
+
+
+class TestMkdir(script.TestCaseWithScript):
+
+    def test_mkdir_usage(self):
+        self.assertRaises(SyntaxError, self.run_script, 'mkdir')
+        self.assertRaises(SyntaxError, self.run_script, 'mkdir foo bar')
+
+    def test_mkdir_jailed(self):
+        self.assertRaises(ValueError, self.run_script, 'mkdir /out-of-jail')
+        self.assertRaises(ValueError, self.run_script, 'mkdir ../out-of-jail')
+
+    def test_mkdir_in_jail(self):
+        self.run_script("""
+mkdir dir
+cd dir
+mkdir ../dir2
+cd ..
+""")
+        self.failUnlessExists('dir')
+        self.failUnlessExists('dir2')
+
+
+class TestCd(script.TestCaseWithScript):
+
+    def test_cd_usage(self):
+        self.assertRaises(SyntaxError, self.run_script, 'cd foo bar')
+
+    def test_cd_out_of_jail(self):
+        self.assertRaises(ValueError, self.run_script, 'cd /out-of-jail')
+        self.assertRaises(ValueError, self.run_script, 'cd ..')
+
+    def test_cd_dir_and_back_home(self):
+        self.assertEquals(self.test_dir, osutils.getcwd())
+        self.run_script("""
+mkdir dir
+cd dir
+""")
+        self.assertEquals(osutils.pathjoin(self.test_dir, 'dir'),
+                          osutils.getcwd())
+
+        self.run_script('cd')
+        self.assertEquals(self.test_dir, osutils.getcwd())
+
+
+class TestBzr(script.TestCaseWithScript):
+
+    def test_bzr_smoke(self):
+        self.run_script('bzr init branch')
+        self.failUnlessExists('branch')
+
+
+class TestEcho(script.TestCaseWithScript):
+
+    def test_echo_usage(self):
+        story = """
+echo foo
+<bar
+"""
+        self.assertRaises(SyntaxError, self.run_script, story)
+
+    def test_echo_to_output(self):
+        out, err = self.run_command(['echo'], None, '\n', None)
+        self.assertEquals('\n', out)
+        self.assertEquals(None, err)
+
+    def test_echo_some_to_output(self):
+        out, err = self.run_command(['echo', 'hello'], None, 'hello\n', None)
+        self.assertEquals('hello\n', out)
+        self.assertEquals(None, err)
+
+    def test_echo_more_output(self):
+        out, err = self.run_command(['echo', 'hello', 'happy', 'world'],
+                                    None, 'hellohappyworld\n', None)
+        self.assertEquals('hellohappyworld\n', out)
+        self.assertEquals(None, err)
+
+    def test_echo_appended(self):
+        out, err = self.run_command(['echo', 'hello', '>file'],
+                                    None, None, None)
+        self.assertEquals(None, out)
+        self.assertEquals(None, err)
+        self.assertFileEqual('hello\n', 'file')
+        out, err = self.run_command(['echo', 'happy', '>>file'],
+                                    None, None, None)
+        self.assertEquals(None, out)
+        self.assertEquals(None, err)
+        self.assertFileEqual('hello\nhappy\n', 'file')