Merge lp:~milo/lava-tool/lava-168 into lp:~linaro-validation/lava-tool/trunk

[Milo Casagrande]

This branch adds the 'lava job run' command to run a job file in the local dispatcher.

[updated: resubmitted, was using wrong target and no prerequisite]

[Antonio Terceiro (terceiro)]

Hi Milo,

Thanks for this. Some of my comments are related to the questions we already
talked about earlier today, but I will also mention them here so others can
also follow.

 review needs-fixing

> === added file 'lava/base_command.py'
> --- lava/base_command.py 1970-01-01 00:00:00 +0000
> +++ lava/base_command.py 2013-06-17 13:33:27 +0000

I would put this somewhere like lava/helper/command.py instead

Maybe when we start working on the other items (testdef/script) we realize that
we can move all of them in the lava.helper namespace instead of creating
lava.testdef and lava.script.

> @@ -0,0 +1,80 @@
> +# Copyright (C) 2013 Linaro Limited
> +#
> +# Author: Milo Casagrande <email address hidden>
> +#
> +# This file is part of lava-tool.
> +#
> +# lava-tool is free software: you can redistribute it and/or modify
> +# it under the terms of the GNU Lesser General Public License version 3
> +# as published by the Free Software Foundation
> +#
> +# lava-tool 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 Lesser General Public License
> +# along with lava-tool. If not, see <http://www.gnu.org/licenses/>.
> +
> +"""Base command class common to lava commands series."""
> +
> +import subprocess
> +
> +from lava.config import InteractiveConfig
> +from lava.tool.command import Command
> +from lava.tool.errors import CommandError
> +
> +
> +class BaseCommand(Command):
> + """Base command class for all lava commands."""
> + def __init__(self, parser, args):
> + super(BaseCommand, self).__init__(parser, args)
> + self.config = InteractiveConfig(
> + force_interactive=self.args.interactive)
> +
> + @classmethod
> + def register_arguments(cls, parser):
> + super(BaseCommand, cls).register_arguments(parser)
> + parser.add_argument("-i", "--interactive",
> + action='store_true',
> + help=("Forces asking for input parameters even if "
> + "we already have them cached."))

As we talked ealier, I think it's better to do it the other way around: assume
interactivity always, and have a --non-interactive option to force not asking
for input.

> +
> + @classmethod
> + def get_dispatcher_paths(cls):
> + """Tries to get the dispatcher paths from lava-dispatcher.
> +
> + :return A list of paths.
> + """
> + try:
> + from lava_dispatcher.config import write_path
> + return write_path()
> + except ImportError:
> + raise CommandError("Cannot find lava-dispatcher installation.")
> +
> + @classmethod
> + def get_devices(cls):
> + """Gets the devices list from the dispatcher.
> +
> + :return A list of DeviceConfig.
> + """
> + try:
> + from lava_dispatcher.config import get_devices
> + return get_devices()
> + except ImportError:
> + raise Comman...

review: Needs Fixing

[lp:~milo/lava-tool/lava-168]

196. By Milo Casagrande on 2013-06-19

Merged latests chanes from parent branch.

197. By Milo Casagrande on 2013-06-19

Refactored the BaseCommand class.

    * Moved BaseCommand in a helper package and in its own class.
    * Refactored method names.
    * Added a dispatcher helper class for all function calls that interact
      or deal with the LAVA dispatcher.

198. By Milo Casagrande on 2013-06-19

Refactored tests.

    * First batch of changes.
    * Added test helper function to collect setUp and tearDown methods.
    * Moved BaseCommand and the new dispatcher method tests here.

199. By Milo Casagrande on 2013-06-19

Refactored tests and commands.

    * Use the new test helper class.
    * Use the new base command class.

200. By Milo Casagrande on 2013-06-19

Use the new base command class.

201. By Milo Casagrande on 2013-06-19

Use os.path.devnull.

202. By Milo Casagrande on 2013-06-19

Added test for the utils module.

203. By Milo Casagrande on 2013-06-19

Added tests to the test suite.

204. By Milo Casagrande on 2013-06-19

Added dispatcher helper tests.

205. By Milo Casagrande on 2013-06-19

Fixed command help.

206. By Milo Casagrande on 2013-06-19

Fixed tests, use new test helper class.

[Milo Casagrande (milo)]

Hi Antonio,

thanks for going through the review!

On Tue, Jun 18, 2013 at 9:13 PM, Antonio Terceiro
<email address hidden> wrote:
> Review: Needs Fixing
>
> Hi Milo,
>
> Thanks for this. Some of my comments are related to the questions we already
> talked about earlier today, but I will also mention them here so others can
> also follow.
>
> review needs-fixing
>
>> === added file 'lava/base_command.py'
>> --- lava/base_command.py 1970-01-01 00:00:00 +0000
>> +++ lava/base_command.py 2013-06-17 13:33:27 +0000
>
> I would put this somewhere like lava/helper/command.py instead

Agree.
This is already done with the latest push.

I also refactored all the calls that made use of the lava-dispatcher
into lava/helper/dispatcher.py, and updated all the tests too.

> Maybe when we start working on the other items (testdef/script) we realize that
> we can move all of them in the lava.helper namespace instead of creating
> lava.testdef and lava.script.
>
>> @@ -0,0 +1,80 @@
>> +# Copyright (C) 2013 Linaro Limited
>> +#
>> +# Author: Milo Casagrande <email address hidden>
>> +#
>> +# This file is part of lava-tool.
>> +#
>> +# lava-tool is free software: you can redistribute it and/or modify
>> +# it under the terms of the GNU Lesser General Public License version 3
>> +# as published by the Free Software Foundation
>> +#
>> +# lava-tool 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 Lesser General Public License
>> +# along with lava-tool. If not, see <http://www.gnu.org/licenses/>.
>> +
>> +"""Base command class common to lava commands series."""
>> +
>> +import subprocess
>> +
>> +from lava.config import InteractiveConfig
>> +from lava.tool.command import Command
>> +from lava.tool.errors import CommandError
>> +
>> +
>> +class BaseCommand(Command):
>> + """Base command class for all lava commands."""
>> + def __init__(self, parser, args):
>> + super(BaseCommand, self).__init__(parser, args)
>> + self.config = InteractiveConfig(
>> + force_interactive=self.args.interactive)
>> +
>> + @classmethod
>> + def register_arguments(cls, parser):
>> + super(BaseCommand, cls).register_arguments(parser)
>> + parser.add_argument("-i", "--interactive",
>> + action='store_true',
>> + help=("Forces asking for input parameters even if "
>> + "we already have them cached."))
>
> As we talked ealier, I think it's better to do it the other way around: assume
> interactivity always, and have a --non-interactive option to force not asking
> for input.

This one is done too.

> I think we should move all the user interaction asking for input to the
> config/parameter classes. This way we use the existing mechanism to store
> answers in configuration and ease users' life.

Agree here too, but I guess there will be some refactoring involved,
and the code review here might...

[lp:~milo/lava-tool/lava-168]

207. By Milo Casagrande on 2013-06-19

PEP8 fixes.

208. By Milo Casagrande on 2013-06-20

Fixed problem with one test.

209. By Milo Casagrande on 2013-06-20

Forced interactiviness to be true.

=== modified file 'lava/config.py'
--- lava/config.py	2013-06-20 08:10:33 +0000
+++ lava/config.py	2013-06-20 08:10:33 +0000
@@ -51,7 +51,7 @@
 
 class InteractiveConfig(object):
 
-    def __init__(self, force_interactive=False):
+    def __init__(self, force_interactive=True):
         self._force_interactive = force_interactive
         self._cache = {}
 

=== modified file 'lava/device/commands.py'
--- lava/device/commands.py	2013-06-20 08:10:33 +0000
+++ lava/device/commands.py	2013-06-20 08:10:33 +0000
@@ -21,23 +21,21 @@
 """
 
 import os
-import subprocess
 import sys
-import random
-import string
-
-from lava.config import InteractiveConfig
+
+from lava.helper.command import (
+    BaseCommand,
+)
+
+from lava.helper.dispatcher import (
+    get_device_file,
+    get_devices_path,
+)
+
 from lava.device import get_known_device
-from lava.tool.command import Command, CommandGroup
+from lava.tool.command import CommandGroup
 from lava.tool.errors import CommandError
-from lava_tool.utils import has_command
 
-# Default lava-dispatcher paths.
-DEFAULT_DISPATCHER_PATH = os.path.join("etc", "lava-dispatcher")
-USER_DISPATCHER_PATH = os.path.join(os.path.expanduser("~"), ".config",
-                                    "lava-dispatcher")
-# Default devices path, has to be joined with the dispatcher path.
-DEFAULT_DEVICES_PATH = "devices"
 DEVICE_FILE_SUFFIX = "conf"
 
 
@@ -47,119 +45,6 @@
     namespace = "lava.device.commands"
 
 
-class BaseCommand(Command):
-    """Base command for device commands."""
-    def __init__(self, parser, args):
-        super(BaseCommand, self).__init__(parser, args)
-        self.config = InteractiveConfig(
-            force_interactive=self.args.interactive)
-
-    @classmethod
-    def register_arguments(cls, parser):
-        super(BaseCommand, cls).register_arguments(parser)
-        parser.add_argument("-i", "--interactive",
-                            action='store_true',
-                            help=("Forces asking for input parameters even if "
-                                  "we already have them cached."))
-
-    @classmethod
-    def _get_dispatcher_paths(cls):
-        """Tries to get the dispatcher from lava-dispatcher."""
-        try:
-            from lava_dispatcher.config import write_path
-            return write_path()
-        except ImportError:
-            raise CommandError("Cannot find lava-dispatcher installation.")
-
-    @classmethod
-    def _choose_devices_path(cls, paths):
-        """Picks the first path that is writable by the user.
-
-        :param paths: A list of paths.
-        :return The first path where it is possible to write.
-        """
-        valid_path = None
-        for path in paths:
-            path = os.path.join(path, DEFAULT_DEVICES_PATH)
-            if os.path.exists(path):
-                name = "".join(random.choice(string.ascii_letters)
-                               for x in range(6))
-                test_file = os.path.join(path, name)
-                try:
-                    fp = open(test_file, 'a')
-                    fp.close()
-                except IOError:
-                    # Cannot write here.
-                    continue
-                else:
-                    valid_path = path
-                    if os.path.isfile(test_file):
-                        os.unlink(test_file)
-                    break
-            else:
-                try:
-                    os.makedirs(path)
-                except OSError:
-                    # Cannot write here either.
-                    continue
-                else:
-                    valid_path = path
-                    break
-        else:
-            raise CommandError("Insufficient permissions to create new "
-                               "devices.")
-        return valid_path
-
-    @classmethod
-    def _get_devices_path(cls):
-        """Gets the path to the devices in the LAVA dispatcher."""
-        dispatcher_paths = cls._get_dispatcher_paths()
-        return cls._choose_devices_path(dispatcher_paths)
-
-    @classmethod
-    def edit_config_file(cls, config_file):
-        """Opens the specified file with the default file editor.
-
-        :param config_file: The file to edit.
-        """
-        editor = os.environ.get("EDITOR", None)
-        if editor is None:
-            if has_command("sensible-editor"):
-                editor = "sensible-editor"
-            elif has_command("xdg-open"):
-                editor = "xdg-open"
-            else:
-                # We really do not know how to open a file.
-                print >> sys.stdout, ("Cannot find an editor to open the "
-                                      "file '{0}'.".format(config_file))
-                print >> sys.stdout, ("Either set the 'EDITOR' environment "
-                                      "variable, or install 'sensible-editor' "
-                                      "or 'xdg-open'.")
-                sys.exit(-1)
-
-        try:
-            subprocess.Popen([editor, config_file]).wait()
-        except Exception:
-            raise CommandError("Error opening the file '{0}' with the "
-                               "following editor: {1}.".format(config_file,
-                                                               editor))
-
-    @classmethod
-    def _get_device_file(cls, file_name):
-        """Retrieves the config file name specified, if it exists.
-
-        :param file_name: The config file name to search.
-        :return The path to the file, or None if it does not exist.
-        """
-        try:
-            from lava_dispatcher.config import get_config_file
-
-            return get_config_file(os.path.join(DEFAULT_DEVICES_PATH,
-                                                file_name))
-        except ImportError:
-            raise CommandError("Cannot find lava-dispatcher installation.")
-
-
 class add(BaseCommand):
     """Adds a new device."""
 
@@ -171,14 +56,14 @@
     def invoke(self):
         real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
 
-        if self._get_device_file(real_file_name):
+        if get_device_file(real_file_name):
             print >> sys.stdout, ("A device configuration file named '{0}' "
                                   "already exists.".format(real_file_name))
             print >> sys.stdout, ("Use 'lava device config {0}' to edit "
                                   "it.".format(self.args.DEVICE))
             sys.exit(-1)
 
-        devices_path = self._get_devices_path()
+        devices_path = get_devices_path()
         device_conf_file = os.path.abspath(os.path.join(devices_path,
                                                         real_file_name))
 
@@ -187,7 +72,7 @@
 
         print >> sys.stdout, ("Created device file '{0}' in: {1}".format(
             real_file_name, devices_path))
-        self.edit_config_file(device_conf_file)
+        self.edit_file(device_conf_file)
 
 
 class remove(BaseCommand):
@@ -201,7 +86,7 @@
 
     def invoke(self):
         real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
-        device_conf = self._get_device_file(real_file_name)
+        device_conf = get_device_file(real_file_name)
 
         if device_conf:
             try:
@@ -224,27 +109,12 @@
         parser.add_argument("DEVICE",
                             help="The name of the device to edit.")
 
-    @classmethod
-    def can_edit_file(cls, conf_file):
-        """Checks if a file can be opend in write mode.
-
-        :param conf_file: The path to the file.
-        :return True if it is possible to write on the file, False otherwise.
-        """
-        can_edit = True
-        try:
-            fp = open(conf_file, "a")
-            fp.close()
-        except IOError:
-            can_edit = False
-        return can_edit
-
     def invoke(self):
         real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
+        device_conf = get_device_file(real_file_name)
 
-        device_conf = self._get_device_file(real_file_name)
         if device_conf and self.can_edit_file(device_conf):
-            self.edit_config_file(device_conf)
+            self.edit_file(device_conf)
         else:
             raise CommandError("Cannot edit file '{0}' at: "
                                "{1}.".format(real_file_name, device_conf))

=== modified file 'lava/device/tests/test_commands.py'
--- lava/device/tests/test_commands.py	2013-06-20 08:10:33 +0000
+++ lava/device/tests/test_commands.py	2013-06-20 08:10:33 +0000
@@ -17,159 +17,84 @@
 # along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Commands class unit tests.
+lava.device.commands unit tests.
 """
 
 import os
-import shutil
-import sys
-import tempfile
 
-from mock import MagicMock
-from unittest import TestCase
+from mock import MagicMock, patch
 
 from lava.device.commands import (
-    BaseCommand,
     add,
     config,
     remove,
 )
-
+from lava.helper.tests.helper_test import HelperTest
 from lava.tool.errors import CommandError
 
 
-class CommandsTest(TestCase):
-    def setUp(self):
-        # Fake the stdout.
-        self.original_stdout = sys.stdout
-        sys.stdout = open("/dev/null", "w")
-        self.original_stderr = sys.stderr
-        sys.stderr = open("/dev/null", "w")
-        self.original_stdin = sys.stdin
-
-        self.device = "a_fake_panda02"
-
-        self.tempdir = tempfile.mkdtemp()
-        self.parser = MagicMock()
-        self.args = MagicMock()
-        self.args.interactive = MagicMock(return_value=False)
-        self.args.DEVICE = self.device
-
-        self.config = MagicMock()
-        self.config.get = MagicMock(return_value=self.tempdir)
-
-    def tearDown(self):
-        sys.stdin = self.original_stdin
-        sys.stdout = self.original_stdout
-        sys.stderr = self.original_stderr
-        shutil.rmtree(self.tempdir)
-
-    def test_get_devices_path_0(self):
-        # Tests that the correct devices path is returned and created.
-        base_command = BaseCommand(self.parser, self.args)
-        base_command.config = self.config
-        BaseCommand._get_dispatcher_paths = MagicMock(return_value=[
-            self.tempdir])
-        obtained = base_command._get_devices_path()
-        expected_path = os.path.join(self.tempdir, "devices")
-        self.assertEqual(expected_path, obtained)
-        self.assertTrue(os.path.isdir(expected_path))
-
-    def test_get_devices_path_1(self):
-        # Tests that when passing a path that is not writable, CommandError
-        # is raised.
-        base_command = BaseCommand(self.parser, self.args)
-        base_command.config = self.config
-        BaseCommand._get_dispatcher_paths = MagicMock(
-            return_value=["/", "/root", "/root/tmpdir"])
-        self.assertRaises(CommandError, base_command._get_devices_path)
-
-    def test_choose_devices_path(self):
-        # Tests that when passing more than one path, the first writable one
-        # is returned.
-        base_command = BaseCommand(self.parser, self.args)
-        base_command.config = self.config
-        obtained = base_command._choose_devices_path(
-            ["/", "/root", self.tempdir, os.path.expanduser("~")])
-        expected = os.path.join(self.tempdir, "devices")
-        self.assertEqual(expected, obtained)
-
-    def test_add_invoke(self):
+class CommandsTest(HelperTest):
+
+    @patch("lava.device.commands.get_device_file",
+           new=MagicMock(return_value=None))
+    @patch("lava.device.commands.get_devices_path")
+    def test_add_invoke(self, get_devices_path_mock):
         # Tests invocation of the add command. Verifies that the conf file is
         # written to disk.
+        get_devices_path_mock.return_value = self.temp_dir
+
         add_command = add(self.parser, self.args)
-        add_command.edit_config_file = MagicMock()
-        add_command._get_device_file = MagicMock(return_value=None)
-        add_command._get_devices_path = MagicMock(return_value=self.tempdir)
+        add_command.edit_file = MagicMock()
         add_command.invoke()
 
-        expected_path = os.path.join(self.tempdir,
+        expected_path = os.path.join(self.temp_dir,
                                      ".".join([self.device, "conf"]))
         self.assertTrue(os.path.isfile(expected_path))
 
-    def test_remove_invoke(self):
+    @patch("lava.device.commands.get_device_file")
+    @patch("lava.device.commands.get_devices_path")
+    def test_remove_invoke(self, get_devices_path_mock, get_device_file_mock):
         # Tests invocation of the remove command. Verifies that the conf file
         # has been correctly removed.
         # First we add a new conf file, then we remove it.
+        get_device_file_mock.return_value = None
+        get_devices_path_mock.return_value = self.temp_dir
+
         add_command = add(self.parser, self.args)
-        add_command.edit_config_file = MagicMock()
-        add_command._get_device_file = MagicMock(return_value=None)
-        add_command._get_devices_path = MagicMock(return_value=self.tempdir)
+        add_command.edit_file = MagicMock()
         add_command.invoke()
 
-        expected_path = os.path.join(self.tempdir,
+        expected_path = os.path.join(self.temp_dir,
                                      ".".join([self.device, "conf"]))
 
+        # Set new values for the mocked function.
+        get_device_file_mock.return_value = expected_path
+
         remove_command = remove(self.parser, self.args)
-        remove_command._get_device_file = MagicMock(return_value=expected_path)
-        remove_command._get_devices_path = MagicMock(return_value=self.tempdir)
         remove_command.invoke()
 
         self.assertFalse(os.path.isfile(expected_path))
 
+    @patch("lava.device.commands.get_device_file",
+           new=MagicMock(return_value="/root"))
     def test_remove_invoke_raises(self):
         # Tests invocation of the remove command, with a non existent device
         # configuration file.
         remove_command = remove(self.parser, self.args)
-        remove_command._get_device_file = MagicMock(return_value="/root")
-
         self.assertRaises(CommandError, remove_command.invoke)
 
+    @patch("lava.device.commands.get_device_file",
+           new=MagicMock(return_value=None))
     def test_config_invoke_raises_0(self):
         # Tests invocation of the config command, with a non existent device
         # configuration file.
         config_command = config(self.parser, self.args)
-        config_command._get_device_file = MagicMock(return_value=None)
-
         self.assertRaises(CommandError, config_command.invoke)
 
+    @patch("lava.device.commands.get_device_file",
+           new=MagicMock(return_value="/etc/password"))
     def test_config_invoke_raises_1(self):
         # Tests invocation of the config command, with a non writable file.
         # Hopefully tests are not run as root.
         config_command = config(self.parser, self.args)
-        config_command._get_device_file = MagicMock(return_value="/etc/passwd")
-
         self.assertRaises(CommandError, config_command.invoke)
-
-    def test_can_edit_file(self):
-        # Tests the can_edit_file method of the config command.
-        # This is to make sure the device config file is not erased when
-        # checking if it is possible to open it.
-        expected = ("hostname = a_fake_panda02\nconnection_command = \n"
-                    "device_type = panda\n")
-
-        config_command = config(self.parser, self.args)
-        try:
-            conf_file = tempfile.NamedTemporaryFile(delete=False)
-
-            with open(conf_file.name, "w") as f:
-                f.write(expected)
-
-            self.assertTrue(config_command.can_edit_file(conf_file.name))
-            obtained = ""
-            with open(conf_file.name) as f:
-                obtained = f.read()
-
-            self.assertEqual(expected, obtained)
-        finally:
-            os.unlink(conf_file.name)

=== modified file 'lava/device/tests/test_device.py'
--- lava/device/tests/test_device.py	2013-06-20 08:10:33 +0000
+++ lava/device/tests/test_device.py	2013-06-20 08:10:33 +0000
@@ -20,34 +20,19 @@
 Device class unit tests.
 """
 
-import os
 import sys
-import tempfile
 
 from StringIO import StringIO
-from unittest import TestCase
 
 from lava.device import (
     Device,
     get_known_device,
 )
 from lava.tool.errors import CommandError
-
-
-class DeviceTest(TestCase):
-
-    def setUp(self):
-        # Fake the stdin and the stdout.
-        self.original_stdout = sys.stdout
-        sys.stdout = open("/dev/null", "w")
-        self.original_stdin = sys.stdin
-        sys.stdin = StringIO()
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-
-    def tearDown(self):
-        sys.stdout = self.original_stdout
-        sys.stdin = self.original_stdin
-        os.unlink(self.temp_file.name)
+from lava.helper.tests.helper_test import HelperTest
+
+
+class DeviceTest(HelperTest):
 
     def test_get_known_device_panda_0(self):
         # User creates a new device with a guessable name for a device.
@@ -108,6 +93,7 @@
     def test_get_known_device_raises(self):
         # User tries to create a new device, but in some way nothing is passed
         # on the command line when asked.
+        sys.stdin = StringIO("\n")
         self.assertRaises(CommandError, get_known_device, 'a_fake_device')
 
     def test_device_write(self):

=== added directory 'lava/helper'
=== added file 'lava/helper/__init__.py'
=== added file 'lava/helper/command.py'
--- lava/helper/command.py	1970-01-01 00:00:00 +0000
+++ lava/helper/command.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,101 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Base command class common to lava commands series."""
+
+import os
+import subprocess
+import sys
+
+
+from lava.config import InteractiveConfig
+from lava.tool.command import Command
+from lava.tool.errors import CommandError
+from lava_tool.utils import has_command
+
+
+class BaseCommand(Command):
+    """Base command class for all lava commands."""
+    def __init__(self, parser, args):
+        super(BaseCommand, self).__init__(parser, args)
+        self.config = InteractiveConfig(
+            force_interactive=self.args.non_interactive)
+
+    @classmethod
+    def register_arguments(cls, parser):
+        super(BaseCommand, cls).register_arguments(parser)
+        parser.add_argument("--non-interactive",
+                            action='store_false',
+                            help=("Do not ask for input parameters."))
+
+    @classmethod
+    def can_edit_file(cls, conf_file):
+        """Checks if a file can be opend in write mode.
+
+        :param conf_file: The path to the file.
+        :return True if it is possible to write on the file, False otherwise.
+        """
+        can_edit = True
+        try:
+            fp = open(conf_file, "a")
+            fp.close()
+        except IOError:
+            can_edit = False
+        return can_edit
+
+    @classmethod
+    def edit_file(cls, config_file):
+        """Opens the specified file with the default file editor.
+
+        :param config_file: The file to edit.
+        """
+        editor = os.environ.get("EDITOR", None)
+        if editor is None:
+            if has_command("sensible-editor"):
+                editor = "sensible-editor"
+            elif has_command("xdg-open"):
+                editor = "xdg-open"
+            else:
+                # We really do not know how to open a file.
+                print >> sys.stdout, ("Cannot find an editor to open the "
+                                      "file '{0}'.".format(config_file))
+                print >> sys.stdout, ("Either set the 'EDITOR' environment "
+                                      "variable, or install 'sensible-editor' "
+                                      "or 'xdg-open'.")
+                sys.exit(-1)
+        try:
+            subprocess.Popen([editor, config_file]).wait()
+        except Exception:
+            raise CommandError("Error opening the file '{0}' with the "
+                               "following editor: {1}.".format(config_file,
+                                                               editor))
+
+    @classmethod
+    def run(cls, cmd_args):
+        """Runs the supplied command args.
+
+        :param cmd_args: The command, and its optional arguments, to run.
+        :return The command execution return code.
+        """
+        if not isinstance(cmd_args, list):
+            cmd_args = list(cmd_args)
+        try:
+            return subprocess.check_call(cmd_args)
+        except subprocess.CalledProcessError:
+            raise CommandError("Error running the following command: "
+                               "{0}".format(" ".join(cmd_args)))

=== added file 'lava/helper/dispatcher.py'
--- lava/helper/dispatcher.py	1970-01-01 00:00:00 +0000
+++ lava/helper/dispatcher.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,110 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Classes and functions to interact with the lava-dispatcher."""
+
+import random
+import string
+import os
+
+from lava.tool.errors import CommandError
+
+# Default devices path, has to be joined with the dispatcher path.
+DEFAULT_DEVICES_PATH = "devices"
+
+
+def get_dispatcher_paths():
+    """Tries to get the dispatcher paths from lava-dispatcher.
+
+    :return A list of paths.
+    """
+    try:
+        from lava_dispatcher.config import write_path
+        return write_path()
+    except ImportError:
+        raise CommandError("Cannot find lava-dispatcher installation.")
+
+
+def get_devices():
+    """Gets the devices list from the dispatcher.
+
+    :return A list of DeviceConfig.
+    """
+    try:
+        from lava_dispatcher.config import get_devices
+        return get_devices()
+    except ImportError:
+        raise CommandError("Cannot find lava-dispatcher installation.")
+
+
+def get_device_file(file_name):
+    """Retrieves the config file name specified, if it exists.
+
+    :param file_name: The config file name to search.
+    :return The path to the file, or None if it does not exist.
+    """
+    try:
+        from lava_dispatcher.config import get_config_file
+        return get_config_file(os.path.join(DEFAULT_DEVICES_PATH,
+                                            file_name))
+    except ImportError:
+        raise CommandError("Cannot find lava-dispatcher installation.")
+
+
+def choose_devices_path(paths):
+    """Picks the first path that is writable by the user.
+
+    :param paths: A list of paths.
+    :return The first path where it is possible to write.
+    """
+    valid_path = None
+    for path in paths:
+        path = os.path.join(path, DEFAULT_DEVICES_PATH)
+        if os.path.exists(path):
+            name = "".join(random.choice(string.ascii_letters)
+                           for x in range(6))
+            test_file = os.path.join(path, name)
+            try:
+                fp = open(test_file, 'a')
+                fp.close()
+            except IOError:
+                # Cannot write here.
+                continue
+            else:
+                valid_path = path
+                if os.path.isfile(test_file):
+                    os.unlink(test_file)
+                break
+        else:
+            try:
+                os.makedirs(path)
+            except OSError:
+                # Cannot write here either.
+                continue
+            else:
+                valid_path = path
+                break
+    else:
+        raise CommandError("Insufficient permissions to create new "
+                           "devices.")
+    return valid_path
+
+
+def get_devices_path():
+    """Gets the path to the devices in the LAVA dispatcher."""
+    return choose_devices_path(get_dispatcher_paths())

=== added directory 'lava/helper/tests'
=== added file 'lava/helper/tests/__init__.py'
=== added file 'lava/helper/tests/helper_test.py'
--- lava/helper/tests/helper_test.py	1970-01-01 00:00:00 +0000
+++ lava/helper/tests/helper_test.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,61 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+A test helper class.
+
+Here we define a general test class and its own setUp and tearDown methods that
+all other test classes can inherit from.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+
+from unittest import TestCase
+from mock import MagicMock
+
+
+class HelperTest(TestCase):
+    """Helper test class that all tests under the lava package can inherit."""
+    def setUp(self):
+        self.original_stdout = sys.stdout
+        sys.stdout = open("/dev/null", "w")
+        self.original_stderr = sys.stderr
+        sys.stderr = open("/dev/null", "w")
+        self.original_stdin = sys.stdin
+
+        self.device = "a_fake_panda02"
+
+        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
+        self.temp_dir = tempfile.mkdtemp()
+        self.parser = MagicMock()
+        self.args = MagicMock()
+        self.args.interactive = MagicMock(return_value=False)
+        self.args.DEVICE = self.device
+
+        self.config = MagicMock()
+        self.config.get = MagicMock(return_value=self.temp_dir)
+
+    def tearDown(self):
+        sys.stdin = self.original_stdin
+        sys.stdout = self.original_stdout
+        sys.stderr = self.original_stderr
+        shutil.rmtree(self.temp_dir)
+        os.unlink(self.temp_file.name)

=== added file 'lava/helper/tests/test_command.py'
--- lava/helper/tests/test_command.py	1970-01-01 00:00:00 +0000
+++ lava/helper/tests/test_command.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,53 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""lava.herlp.command module tests."""
+
+from lava.helper.command import BaseCommand
+from lava.helper.tests.helper_test import HelperTest
+
+
+class BaseCommandTests(HelperTest):
+
+    def test_register_argument(self):
+        # Make sure that the parser add_argument is called and we have the
+        # correct argument.
+        command = BaseCommand(self.parser, self.args)
+        command.register_arguments(self.parser)
+        name, args, kwargs = self.parser.method_calls[0]
+        self.assertIn("--non-interactive", args)
+
+    def test_can_edit_file(self):
+        # Tests the can_edit_file method of the config command.
+        # This is to make sure the device config file is not erased when
+        # checking if it is possible to open it.
+        expected = ("hostname = a_fake_panda02\nconnection_command = \n"
+                    "device_type = panda\n")
+
+        command = BaseCommand(self.parser, self.args)
+        conf_file = self.temp_file
+
+        with open(conf_file.name, "w") as f:
+            f.write(expected)
+
+        self.assertTrue(command.can_edit_file(conf_file.name))
+        obtained = ""
+        with open(conf_file.name) as f:
+            obtained = f.read()
+
+        self.assertEqual(expected, obtained)

=== added file 'lava/helper/tests/test_dispatcher.py'
--- lava/helper/tests/test_dispatcher.py	1970-01-01 00:00:00 +0000
+++ lava/helper/tests/test_dispatcher.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,52 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""lava.helper.dispatcher tests."""
+
+import os
+from lava.tool.errors import CommandError
+
+from lava.helper.tests.helper_test import HelperTest
+
+from lava.helper.dispatcher import (
+    choose_devices_path,
+)
+
+
+class DispatcherTests(HelperTest):
+
+    def test_choose_devices_path_0(self):
+        # Tests that when passing more than one path, the first writable one
+        # is returned.
+        obtained = choose_devices_path(
+            ["/", "/root", self.temp_dir, os.path.expanduser("~")])
+        expected = os.path.join(self.temp_dir, "devices")
+        self.assertEqual(expected, obtained)
+
+    def test_choose_devices_path_1(self):
+        # Tests that when passing a path that is not writable, CommandError
+        # is raised.
+        self.assertRaises(CommandError, choose_devices_path,
+                          ["/", "/root", "/root/tmpdir"])
+
+    def test_choose_devices_path_2(self):
+        # Tests that the correct path for devices is created on the filesystem.
+        expected_path = os.path.join(self.temp_dir, "devices")
+        obtained = choose_devices_path([self.temp_dir])
+        self.assertEqual(expected_path, obtained)
+        self.assertTrue(os.path.isdir(expected_path))

=== modified file 'lava/job/__init__.py'
--- lava/job/__init__.py	2013-05-28 22:08:12 +0000
+++ lava/job/__init__.py	2013-06-20 08:10:33 +0000
@@ -21,12 +21,13 @@
 
 from lava.job.templates import Parameter
 
+
 class Job:
-
     def __init__(self, template):
         self.data = deepcopy(template)
 
     def fill_in(self, config):
+
         def insert_data(data):
             if isinstance(data, dict):
                 keys = data.keys()
@@ -44,4 +45,3 @@
 
     def write(self, stream):
         stream.write(json.dumps(self.data, indent=4))
-

=== modified file 'lava/job/commands.py'
--- lava/job/commands.py	2013-06-03 18:06:49 +0000
+++ lava/job/commands.py	2013-06-20 08:10:33 +0000
@@ -16,40 +16,34 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
 
-from os.path import exists
-
-from lava.config import InteractiveConfig
+"""
+LAVA job commands.
+"""
+
+import os
+import sys
+import xmlrpclib
+
+from lava.helper.command import BaseCommand
+
+from lava.config import Parameter
 from lava.job import Job
-from lava.job.templates import *
-from lava.tool.command import Command, CommandGroup
+from lava.job.templates import (
+    BOOT_TEST,
+)
+from lava.tool.command import CommandGroup
 from lava.tool.errors import CommandError
-
 from lava_tool.authtoken import AuthenticatingServerProxy, KeyringAuthBackend
-import xmlrpclib
+from lava_tool.utils import has_command
+
 
 class job(CommandGroup):
-    """
-    LAVA job file handling
-    """
-
+    """LAVA job file handling."""
     namespace = 'lava.job.commands'
 
-class BaseCommand(Command):
-
-    def __init__(self, parser, args):
-        super(BaseCommand, self).__init__(parser, args)
-        self.config = InteractiveConfig(force_interactive=self.args.interactive)
-
-    @classmethod
-    def register_arguments(cls, parser):
-        super(BaseCommand, cls).register_arguments(parser)
-        parser.add_argument(
-            "-i", "--interactive",
-            action='store_true',
-            help=("Forces asking for input parameters even if we already "
-                  "have them cached."))
 
 class new(BaseCommand):
+    """Creates a new job file."""
 
     @classmethod
     def register_arguments(cls, parser):
@@ -57,20 +51,22 @@
         parser.add_argument("FILE", help=("Job file to be created."))
 
     def invoke(self):
-        if exists(self.args.FILE):
-            raise CommandError('%s already exists' % self.args.FILE)
+        if os.path.exists(self.args.FILE):
+            raise CommandError('{0} already exists.'.format(self.args.FILE))
 
-        with open(self.args.FILE, 'w') as f:
-            job = Job(BOOT_TEST)
-            job.fill_in(self.config)
-            job.write(f)
+        with open(self.args.FILE, 'w') as job_file:
+            job_instance = Job(BOOT_TEST)
+            job_instance.fill_in(self.config)
+            job_instance.write(job_file)
 
 
 class submit(BaseCommand):
+    """Submits the specified job file."""
+
     @classmethod
     def register_arguments(cls, parser):
         super(submit, cls).register_arguments(parser)
-        parser.add_argument("FILE", help=("The job file to submit"))
+        parser.add_argument("FILE", help=("The job file to submit."))
 
     def invoke(self):
         jobfile = self.args.FILE
@@ -85,10 +81,61 @@
                                            auth_backend=KeyringAuthBackend())
         try:
             job_id = server.scheduler.submit_job(jobdata)
-            print "Job submitted with job ID %d" % job_id
-        except xmlrpclib.Fault, e:
-            raise CommandError(str(e))
+            print >> sys.stdout, "Job submitted with job ID {0}".format(job_id)
+        except xmlrpclib.Fault, exc:
+            raise CommandError(str(exc))
+
 
 class run(BaseCommand):
+    """Runs the specified job file on the local dispatcher."""
+
+    @classmethod
+    def register_arguments(cls, parser):
+        super(run, cls).register_arguments(parser)
+        parser.add_argument("FILE", help=("The job file to submit."))
+
+    @classmethod
+    def _choose_device(cls, devices):
+        """Let the user choose the device to use.
+
+        :param devices: The list of available devices.
+        :return The selected device.
+        """
+        devices_len = len(devices)
+        output_list = []
+        for device, number in zip(devices, range(1, devices_len + 1)):
+            output_list.append("\t{0}. {1}\n".format(number, device.hostname))
+
+        print >> sys.stdout, ("More than one local device found. "
+                              "Please choose one:\n")
+        print >> sys.stdout, "".join(output_list)
+
+        while True:
+            try:
+                user_input = raw_input("Device number to use: ").strip()
+
+                if user_input in [str(x) for x in range(1, devices_len + 1)]:
+                    return devices[int(user_input) - 1].hostname
+                else:
+                    continue
+            except EOFError:
+                user_input = None
+            except KeyboardInterrupt:
+                sys.exit(-1)
+
     def invoke(self):
-        print("hello world")
+        if os.path.isfile(self.args.FILE):
+            if has_command("lava-dispatch"):
+                devices = self.get_devices()
+                if devices:
+                    if len(devices) > 1:
+                        device = self._choose_device(devices)
+                    else:
+                        device = devices[0].hostname
+                    self.run(["lava-dispatch", "--target", device,
+                              self.args.FILE])
+            else:
+                raise CommandError("Cannot find lava-dispatcher installation.")
+        else:
+            raise CommandError("The file '{0}' does not exists. or is not "
+                               "a file.".format(self.args.FILE))

=== modified file 'lava/job/tests/test_commands.py'
--- lava/job/tests/test_commands.py	2013-06-03 18:06:49 +0000
+++ lava/job/tests/test_commands.py	2013-06-20 08:10:33 +0000
@@ -20,74 +20,95 @@
 Unit tests for the commands classes
 """
 
-from argparse import ArgumentParser
 import json
-from os import (
-    makedirs,
-    removedirs,
-)
-from os.path import(
-    exists,
-    join,
-)
-from shutil import(
-    rmtree,
-)
-from tempfile import mkdtemp
-from unittest import TestCase
-
-from lava.config import NonInteractiveConfig
-from lava.job.commands import *
+import os
+
+from mock import MagicMock, patch
+
+from lava.config import NonInteractiveConfig, Parameter
+
+from lava.job.commands import (
+    new,
+    run,
+    submit,
+)
+
+from lava.helper.tests.helper_test import HelperTest
 from lava.tool.errors import CommandError
 
-from mocker import Mocker
-
-def make_command(command, *args):
-    parser = ArgumentParser(description="fake argument parser")
-    command.register_arguments(parser)
-    the_args = parser.parse_args(*args)
-    cmd = command(parser, the_args)
-    cmd.config = NonInteractiveConfig({ 'device_type': 'foo', 'prebuilt_image': 'bar' })
-    return cmd
-
-class CommandTest(TestCase):
+
+class CommandTest(HelperTest):
 
     def setUp(self):
-        self.tmpdir = mkdtemp()
+        super(CommandTest, self).setUp()
+        self.args.FILE = self.temp_file.name
 
-    def tearDown(self):
-        rmtree(self.tmpdir)
+        self.device_type = Parameter('device_type')
+        self.prebuilt_image = Parameter('prebuilt_image',
+                                        depends=self.device_type)
+        self.config = NonInteractiveConfig(
+            {'device_type': 'foo', 'prebuilt_image': 'bar'})
 
     def tmp(self, filename):
-        return join(self.tmpdir, filename)
+        """Returns a path to a non existent file.
+
+        :param filename: The name the file should have.
+        :return A path.
+        """
+        return os.path.join(self.temp_dir, filename)
+
 
 class JobNewTest(CommandTest):
 
+    def setUp(self):
+        super(JobNewTest, self).setUp()
+        self.args.FILE = self.tmp("new_file.json")
+        self.new_command = new(self.parser, self.args)
+        self.new_command.config = self.config
+
+    def tearDown(self):
+        super(JobNewTest, self).tearDown()
+        if os.path.exists(self.args.FILE):
+            os.unlink(self.args.FILE)
+
     def test_create_new_file(self):
-        f = self.tmp('file.json')
-        command = make_command(new, [f])
-        command.invoke()
-        self.assertTrue(exists(f))
+        self.new_command.invoke()
+        self.assertTrue(os.path.exists(self.args.FILE))
 
     def test_fills_in_template_parameters(self):
-        f = self.tmp('myjob.json')
-        command = make_command(new, [f])
-        command.invoke()
+        self.new_command.invoke()
 
-        data = json.loads(open(f).read())
+        data = json.loads(open(self.args.FILE).read())
         self.assertEqual(data['device_type'], 'foo')
 
-    def test_wont_overwriteexisting_file(self):
-        existing = self.tmp('existing.json')
-        with open(existing, 'w') as f:
+    def test_wont_overwrite_existing_file(self):
+        with open(self.args.FILE, 'w') as f:
             f.write("CONTENTS")
-        command = make_command(new, [existing])
-        with self.assertRaises(CommandError):
-            command.invoke()
-        self.assertEqual("CONTENTS", open(existing).read())
+
+        self.assertRaises(CommandError, self.new_command.invoke)
+        self.assertEqual("CONTENTS", open(self.args.FILE).read())
+
 
 class JobSubmitTest(CommandTest):
 
     def test_receives_job_file_in_cmdline(self):
-        cmd = make_command(new, ['FOO.json'])
-        self.assertEqual('FOO.json', cmd.args.FILE)
+        command = submit(self.parser, self.args)
+        command.register_arguments(self.parser)
+        name, args, kwargs = self.parser.method_calls[1]
+        self.assertIn("FILE", args)
+
+
+class JobRunTest(CommandTest):
+
+    def test_invoke_raises_0(self):
+        # Users passes a non existing job file to the run command.
+        self.args.FILE = self.tmp("test_invoke_raises_0.json")
+        command = run(self.parser, self.args)
+        self.assertRaises(CommandError, command.invoke)
+
+    @patch("lava.job.commands.has_command", new=MagicMock(return_value=False))
+    def test_invoke_raises_1(self):
+        # Users passes a valid file to the run command, but she does not have
+        # the dispatcher installed.
+        command = run(self.parser, self.args)
+        self.assertRaises(CommandError, command.invoke)

=== modified file 'lava_tool/tests/__init__.py'
--- lava_tool/tests/__init__.py	2013-06-20 08:10:33 +0000
+++ lava_tool/tests/__init__.py	2013-06-20 08:10:33 +0000
@@ -38,11 +38,14 @@
         'lava_tool.tests.test_authtoken',
         'lava_tool.tests.test_auth_commands',
         'lava_tool.tests.test_commands',
+        'lava_tool.tests.test_utils',
         'lava_dashboard_tool.tests.test_commands',
         'lava.job.tests.test_job',
         'lava.job.tests.test_commands',
         'lava.device.tests.test_device',
         'lava.device.tests.test_commands',
+        'lava.helper.tests.test_command',
+        'lava.helper.tests.test_dispatcher',
     ]
 
 

=== added file 'lava_tool/tests/test_utils.py'
--- lava_tool/tests/test_utils.py	1970-01-01 00:00:00 +0000
+++ lava_tool/tests/test_utils.py	2013-06-20 08:10:33 +0000
@@ -0,0 +1,41 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Milo Casagrande <[e-mail]>
+#
+# This file is part of lava-tool.
+#
+# lava-tool is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation
+#
+# lava-tool 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 Lesser General Public License
+# along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
+
+"""lava_tool.utils tests."""
+
+import subprocess
+
+from unittest import TestCase
+from mock import patch
+
+from lava_tool.utils import has_command
+
+
+class UtilTests(TestCase):
+
+    @patch("lava_tool.utils.subprocess.check_call")
+    def test_has_command_0(self, mocked_check_call):
+        # Make sure we raise an exception when the subprocess is called.
+        mocked_check_call.side_effect = subprocess.CalledProcessError(0, "")
+        self.assertFalse(has_command(""))
+
+    @patch("lava_tool.utils.subprocess.check_call")
+    def test_has_command_1(self, mocked_check_call):
+        # Check that a "command" exists. The call to subprocess is mocked.
+        mocked_check_call.return_value = 0
+        self.assertTrue(has_command(""))

=== modified file 'lava_tool/utils.py'
--- lava_tool/utils.py	2013-06-20 08:10:33 +0000
+++ lava_tool/utils.py	2013-06-20 08:10:33 +0000
@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with lava-tool.  If not, see <http://www.gnu.org/licenses/>.
 
+import os
 import subprocess
 
 
@@ -27,7 +28,7 @@
     command_available = True
     try:
         subprocess.check_call(["which", command],
-                              stdout=open('/dev/null', 'w'))
+                              stdout=open(os.path.devnull, 'w'))
     except subprocess.CalledProcessError:
         command_available = False
     return command_available