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

[Milo Casagrande]

This is work in progress for Jira card LAVA-167. Early work to take a look if I'm on the right track.

[Milo Casagrande (milo)]

Updated status to be in need review, code should be ready for general review.

Added also here are pep8 and pyflakes tests (although they give errors while running via the ci-build script).

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

216. By Milo Casagrande on 2013-06-10

Added missing dependencies to run tests.

    * pep8 and pyflakes depends on testtools, since it gives a nicer
      output on errors.

[Milo Casagrande (milo)]

With commit #216 even the ci-build script now works. pep8 and pyflakes tests depend on testtools package since it provides a better error output on test runs.

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

217. By Milo Casagrande on 2013-06-10

Fixed config command test.

218. By Milo Casagrande on 2013-06-10

Refactored command tests: defined device name on setup.

[Zygmunt Krynicki (zyga)]

9 +versiontools-1.9.1-py2.7.egg

You probably want to ignore *.egg

[Zygmunt Krynicki (zyga)]

All the stuff around testing. You'd better just depend on py.test or something like that, it has that exact stuff integrated and ready. You may also find that just blindly enabling pyflakes and pep8 will throw lots of errors at you (unless lava is perfect, I doubt that). The better approach would be to use a diff mode and only run that at merge request time. Then you at least don't introduce _new_ issues.

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

219. By Milo Casagrande on 2013-06-10

Fixed ignored .egg pattern.

[Milo Casagrande (milo)]

On Mon, Jun 10, 2013 at 3:00 PM, Zygmunt Krynicki
<email address hidden> wrote:
> All the stuff around testing. You'd better just depend on py.test or something like that, it has that exact stuff integrated and ready.

Never heard about that, will give it a look. Thanks for the pointer!
Thanks also for the *.egg in bzrignore.

> You may also find that just blindly enabling pyflakes and pep8 will throw lots of errors at you (unless lava is perfect, I doubt that). The better approach would be to use a diff mode and only run that at merge request time. Then you at least don't introduce _new_ issues.

I agree, I'm not that happy with that too, I was thinking about a
git/bzr pre-[commit|push] hook, but at least for now (and locally,
testing only the lava-tool) I prefer having those error thrown at me.
For lava-tool they shouldn't even be too hard to fix.

--
Milo Casagrande | Automation Engineer
Linaro.org <www.linaro.org> │ Open source software for ARM SoCs

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

220. By Milo Casagrande on 2013-06-10

Removed pep8 and pyflakes tests.

    * At this stage better have them as part of a pre-commit hook.

[Milo Casagrande (milo)]

I removed the pep8 and pyflakes tests from the project. Fixing them would not take too much, but there are some, in particular doctest ones, that might be a trickier to fix.

At this stage it makes more sense to provide pre-commit or pre-push hooks for git/bzr to run pep8/pyflakes/pylint/...

[Antonio Terceiro (terceiro)]

Hi Milo,

Very nice progress here! I have some comments below to help improving it.

 review needs-fixing

Also I wonder whether we should merge my branch into trunk already so
you don't keep developing off the official places ... it's not like
there will be a release before this work is done with.

> === modified file '.bzrignore'
> --- .bzrignore 2013-06-10 15:38:27 +0000
> +++ .bzrignore 2013-06-10 15:38:27 +0000
> @@ -3,3 +3,6 @@
> ./build
> ./dist
> /tags
> +.testrepository
> +*.egg
> +ci-build-venv

you won't need the last one anymore.

> === added file '.testr.conf'
> --- .testr.conf 1970-01-01 00:00:00 +0000
> +++ .testr.conf 2013-06-10 15:38:27 +0000
> @@ -0,0 +1,3 @@
> +[DEFAULT]
> +test_command=python -m subunit.run $IDLIST
> +test_id_list_default=lava_tool.tests.test_suite
>
> === modified file 'ci-build'
> --- ci-build 2013-06-10 15:38:27 +0000
> +++ ci-build 2013-06-10 15:38:27 +0000
> @@ -1,11 +1,13 @@
> #!/bin/sh
>
> +VENV_DIR="/tmp/ci-build-venv"
> +
> set -e
>
> if test -z "$VIRTUAL_ENV"; then
> set -x
> - virtualenv ci-build-venv
> - . ci-build-venv/bin/activate
> + virtualenv $VENV_DIR
> + . $VENV_DIR/bin/activate
> python setup.py develop
> fi
>
> @@ -21,6 +23,22 @@
> pip install mocker
> fi
>
> +if ! pip show pep8 | grep -q pep8; then
> + pip install pep8
> +fi
> +
> +if ! pip show pyflakes | grep -q pyflakes; then
> + pip install pyflakes
> +fi
> +
> +if ! pip show testtools | grep -q testtools; then
> + pip install testtools
> +fi
> +
> +if ! pip show mock | grep -q mock; then
> + pip install mock
> +fi
> +
> export LAVACONFIG=/dev/null
>
> if test -z "$DISPLAY"; then
>

if you dropped pyflakes/pep8 tests there is no point in installing them
here.

> === added directory 'lava/device'
> === added file 'lava/device/__init__.py'
> --- lava/device/__init__.py 1970-01-01 00:00:00 +0000
> +++ lava/device/__init__.py 2013-06-10 15:38:27 +0000
> @@ -0,0 +1,112 @@
> +# 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/>.
> +
> +import re
> +
> +from lava.device.templates import DEFAULT_TEMPLATE
> +from lava.tool.errors import CommandError
> +
> +
> +class Device(object):
> + """A generic device."""
> + def __init__(self, name):
> + super(Device, self).__init__()

I don't think object has anything useful in its constructor.

> + self.device_type = None
> + self.hostname = name
> + self.template = DEFAULT_TEMPLATE

In _update you are changing this object, you might want to ...

review: Needs Fixing

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

221. By Milo Casagrande on 2013-06-11

Removed unnecessary ignore rule.

222. By Milo Casagrande on 2013-06-11

Cleaned up dependencies.

223. By Milo Casagrande on 2013-06-11

Renamed variable name.

224. By Milo Casagrande on 2013-06-11

Reworked the Device class.

    * Removed PandaDevice class, fixed tests.
    * Added couple more tests.
    * Added a panda template, a vexpress one and refactored how the
      known devices dictionary is built.
    * Some PEP8 and pylint cleaning.

225. By Milo Casagrande on 2013-06-11

Fixed subprocess call.

[Milo Casagrande (milo)]

Hi Antonio!

Thanks for the review.

On Tue, Jun 11, 2013 at 2:31 AM, Antonio Terceiro
<email address hidden> wrote:
> Review: Needs Fixing
>
> Hi Milo,
>
> Very nice progress here! I have some comments below to help improving it.
>
> review needs-fixing
>
> Also I wonder whether we should merge my branch into trunk already so
> you don't keep developing off the official places ... it's not like
> there will be a release before this work is done with.

As you prefer, I based my branch on yours so the diff would make sense here.
As soon as we merge that we can switch to trunk.

> if you dropped pyflakes/pep8 tests there is no point in installing them
> here.

Forgot to clean up those dependencies. Cleared them all out, and
cleaned also the bzrignore file.

> I don't think object has anything useful in its constructor.

Default code snippet/autocompletion when I create classes. I usually
do not even pay attention to that.
Cleared out.

> In _update you are changing this object, you might want to make a copy instead.

Makes sense, indeed.

>> +
>> + def write(self, where):
>> + """Writes the object to file.
>> +
>> + :param where: The full path of the file where to write."""
>> + with open(where, 'w') as f:
>> + f.write(self.__str__())
>
> renaming `where` to `file` will make the code a lot more obvious.

I used `conf_file`, I do not like using the same name as the built-in
"file" for a variable even if it is as simple as in this case (plus
there is the description just above/below).

>> +# Dictionary with key the name of a know device, and value a tuple composed of
>> +# a matcher used to guess the device type, and its associated Device class.
>> +known_devices = {
>> + 'panda': (re.compile('^.*panda.*', re.I), PandaDevice),
>> +}
>
> you might create this dynamically from a list of device type names. I don't
> see us needing one class per device type, so perhaps the last element in the
> value tuple should be a template, which could be looked up by device type name
> in lava.device.templates, or a default if the device type name does not bring
> anything.

I cleaned up this part, removing the specialized PandaDevice class and
creating "custom" templates.
Take a look of what I did was how you were thinking about.

The regex matcher is also create "on-the-fly".

> I think you cannot always assume an instance here. If you have lava-tool
> installed with Debian packages, then you don't have a local instance. The
> problem is that the dispatcher does not expose a list of configuration
> directories that we can reference. I will work on this tomorrow, and will let
> you know.

Yeah, I was looking into getting as much info as possible out of LAVA,
but for what I needed I didn't have much luck.
Indeed this part here needs a better logic, but I wanted to have the
code out there for a first review.

> I think we could keep a dictionary of templates, indexed by device type (see
> also my comments above wrt lava.device.__init__.py)

This should have been addressed. Please take a look and let me know.

> CalledProcessError will never be raised here. It's only raised by check_call
> and check_output.
>
> try th...

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

226. By Milo Casagrande on 2013-06-11

Reworked docstring for command line help.

227. By Milo Casagrande on 2013-06-11

Reworked how new templates are created.

228. By Milo Casagrande on 2013-06-11

Used dict copy instead of importing copy module.

229. By Milo Casagrande on 2013-06-11

Removed rm from the entry points: it showed up as remove in the command list.

230. By Milo Casagrande on 2013-06-11

Refactored string formatting to be more Python3 compliant.

231. By Milo Casagrande on 2013-06-12

Refactoring and tests fixed.

    * Added function to get from lava-dispatcher the config paths.
    * Some cleanups and refactoring.

232. By Milo Casagrande on 2013-06-12

Made the user choose the correct path to use.

    * Added logic to handle user input.
    * Fixed tests.

233. By Milo Casagrande on 2013-06-12

Added new test.

[Antonio Terceiro (terceiro)]

> == added file 'lava/device/commands.py'
> -- lava/device/commands.py 1970-01-01 00:00:00 +0000
> ++ lava/device/commands.py 2013-06-12 13:21:33 +0000
> @ -0,0 +1,237 @@
[snip]
> # 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")

It would be better to

  from lava_dispatcher.import user_config_path, system_config_path

and use those instead, so you don't need to duplicate the logic here. We don't
want to make the dispatcher a hard dependency of lava-tool, but if we don't
have the dispatcher available, just fail the entire thing.

> # Default devices path, has to be joined with the dispatcher path.
> DEFAULT_DEVICES_PATH = "devices"
> DEVICE_FILE_SUFFIX = "conf"
>
>
> class device(CommandGroup):
> """LAVA devices handling."""
>
> 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."""
> global_paths = []
> try:
> from lava_dispatcher.config import search_path
>
> global_paths += search_path()
> except ImportError:
> print >> sys.stderr, "Cannot import lava_dispatcher."

Right here. We should baild out if the dispatcher is not available for device
management. After all without a local dispatcher there is no point in managing
devices.

> return global_paths
>
> @classmethod
> def _choose_dispatcher_path(cls, paths):
> """Lets the user choose the path to use.
>
> :param paths: A list of paths.
> :return The path at the user selected index.
> """
> print >> sys.stdout, ("Multiple dispatcher paths found. Please "
> "select one between:\n")
> out_list = []
> len_paths = range(1, len(paths) + 1)
> for index, dispatcher_path in zip(len_paths, paths):
> out_list.append("\t{0}. {1}\n".format(index, dispatcher_path))
> print >> sys.stdout, "".join(out_list)
> while True:
> try:
> choice = raw_input("Dispatcher path to use: ").strip()
> if choice in [str(x) for x in len_paths]:
> return paths[int(choice) - 1]
> else:
> continue
> except KeyboardInterrupt:
> sys.exit(-1)

I think we should not g...

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

234. By Milo Casagrande on 2013-06-13

Fixed templates.

235. By Milo Casagrande on 2013-06-13

Fixed command logic to use lava_dispatcher.

    * We now soft depend on lava_dispatcher: if it is not installed, execution
      will not continue.
    * Fixed tests.

[Milo Casagrande (milo)]

On Thu, Jun 13, 2013 at 2:46 AM, Antonio Terceiro
<email address hidden> wrote:
>> == added file 'lava/device/commands.py'
>> -- lava/device/commands.py 1970-01-01 00:00:00 +0000
>> ++ lava/device/commands.py 2013-06-12 13:21:33 +0000
>> @ -0,0 +1,237 @@
> [snip]
>> # 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")
>
> It would be better to
>
> from lava_dispatcher.import user_config_path, system_config_path
>
> and use those instead, so you don't need to duplicate the logic here. We don't
> want to make the dispatcher a hard dependency of lava-tool, but if we don't
> have the dispatcher available, just fail the entire thing.

Modifying the logic in the _get_dispatcher_paths() and the other
methods that deal with picking the correct path, I think it is not
necessary to import "user_config_path" and "system_config_path" from
the dispatcher.

Since we get the paths via lava_dispatcher.config.search_path(), it
will return those paths already, and if we cannot import it we will
fail.

> Right here. We should baild out if the dispatcher is not available for device
> management. After all without a local dispatcher there is no point in managing
> devices.

Sounds cool.
I was trying to be a little bit more "gentle" and fallback to let
users create devices anyway. :-)

> I think we should not give too many options here: if the user is capable of
> choosing the right directory to write to, he doesn't need lava-tool to do it
> for him; he would just create a file with $EDITOR there.
>
> Instead of this, I think you should assume that dispatcher branch of mine, and
> use the following strategy:
>
> 1) finding where to create a new configurarion file:
>
> the first of [system_dispatcher_path, user_config_path] that is writable
>
> 2) finding an existing configuration file to edit:
>
> from lava_dispatcher.config import get_config_file
> [...]
>
> conf_file = get_config_file("devices/%s.conf", device_name)
> if conf_file:
> # edit
> else:
> print("No device %s found" % device_name)
> exit(-1)
>
> I think that doing this will simplify a lot things in this file.

OK, I reworked this part, probably in a slighter different way.
This is how it will work now for the add command:

- We check if a device with that config file name already exists: this
is now done with lava_dispatcher.config.get_config_file. If we cannot
import the function, we fail.
- If the device already exists, we exit printing to use "lava device
config DEVICE" (as was before)
- Otherwise, get the paths from the dispatcher using
lava_dispatcher.config.search_path() (again, if it gives errors we
fail)
- Check if one of those paths is writable and pick the first one that
is, otherwise fail
- At this stage we are sure that the device doesn't exists and we can create it.

There might be another check we want to do though: if
lava_dispatcher.config.get_config_file() returns a path to an existing
file that is not writable by the user (in particular for the "config"
command).

> I think something l...

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

236. By Milo Casagrande on 2013-06-13

Fixed print statements, added one on remove command.

237. By Milo Casagrande on 2013-06-13

Minor fixes on printing statements.

238. By Milo Casagrande on 2013-06-13

Minor fixes on printing statements: fixed typos.

239. By Milo Casagrande on 2013-06-13

Fixed two tests.

240. By Milo Casagrande on 2013-06-13

Fixed one test.

241. By Milo Casagrande on 2013-06-13

Fixed logic when choosing devices path.

242. By Milo Casagrande on 2013-06-13

Better output on add command.

[Antonio Terceiro (terceiro)]

On Thu, Jun 13, 2013 at 10:35:00AM -0000, Milo Casagrande wrote:
> > I think we should not give too many options here: if the user is capable of
> > choosing the right directory to write to, he doesn't need lava-tool to do it
> > for him; he would just create a file with $EDITOR there.
> >
> > Instead of this, I think you should assume that dispatcher branch of mine, and
> > use the following strategy:
> >
> > 1) finding where to create a new configurarion file:
> >
> > the first of [system_dispatcher_path, user_config_path] that is writable
> >
> > 2) finding an existing configuration file to edit:
> >
> > from lava_dispatcher.config import get_config_file
> > [...]
> >
> > conf_file = get_config_file("devices/%s.conf", device_name)
> > if conf_file:
> > # edit
> > else:
> > print("No device %s found" % device_name)
> > exit(-1)
> >
> > I think that doing this will simplify a lot things in this file.
>
> OK, I reworked this part, probably in a slighter different way.
> This is how it will work now for the add command:
>
> - We check if a device with that config file name already exists: this
> is now done with lava_dispatcher.config.get_config_file. If we cannot
> import the function, we fail.
> - If the device already exists, we exit printing to use "lava device
> config DEVICE" (as was before)
> - Otherwise, get the paths from the dispatcher using
> lava_dispatcher.config.search_path() (again, if it gives errors we
> fail)
> - Check if one of those paths is writable and pick the first one that
> is, otherwise fail

It cannot be the first of search_path. Say you write to user_config_path
(~user/.config/...). For some(most?) devices, at the moment you need to
run the dispatcher as root. The dispatcher will then look at
~root/config/... , and will not find anything the device.

Also, picking some path in search_path involves the (small, but
non-zero) risk of writing to the default_config_path, what we don't want.

Maybe we could just export [system_config_path, user_config_path] as
lava_dispatcher.config.write_search_path, then, keep your logic of find
the first?

> - At this stage we are sure that the device doesn't exists and we can create it.
>
> There might be another check we want to do though: if
> lava_dispatcher.config.get_config_file() returns a path to an existing
> file that is not writable by the user (in particular for the "config"
> command).

Yep.

--
Antonio Terceiro
Software Engineer - Linaro
http://www.linaro.org

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

243. By Milo Casagrande on 2013-06-13

Fixed use of lava_dispatcher function to retrieve config write path.

244. By Milo Casagrande on 2013-06-13

Added test for editing device file.

[Milo Casagrande (milo)]

On Thu, Jun 13, 2013 at 4:24 PM, Antonio Terceiro
<email address hidden> wrote:
>
> It cannot be the first of search_path. Say you write to user_config_path
> (~user/.config/...). For some(most?) devices, at the moment you need to
> run the dispatcher as root. The dispatcher will then look at
> ~root/config/... , and will not find anything the device.
>
> Also, picking some path in search_path involves the (small, but
> non-zero) risk of writing to the default_config_path, what we don't want.
>
> Maybe we could just export [system_config_path, user_config_path] as
> lava_dispatcher.config.write_search_path, then, keep your logic of find
> the first?

I fixed this using your latest changes in the dispatcher.
I also added a test when editing the config file to check if it is
writable or not.

--
Milo Casagrande | Automation Engineer
Linaro.org <www.linaro.org> │ Open source software for ARM SoCs

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

245. By Milo Casagrande on 2013-06-13

Fixed method name error.

246. By Milo Casagrande on 2013-06-13

Added another test.

247. By Milo Casagrande on 2013-06-13

Fixed opening of file: opening with 'w' ereases the file.

248. By Milo Casagrande on 2013-06-13

Use append mode also in another case for file opening.

249. By Milo Casagrande on 2013-06-13

Fixed output.

250. By Milo Casagrande on 2013-06-13

Fixed tests.

251. By Milo Casagrande on 2013-06-13

Added a new test.

252. By Milo Casagrande on 2013-06-14

Fixed the can_edit_file test.

253. By Milo Casagrande on 2013-06-19

Merged from trunk.

=== modified file '.bzrignore'
--- .bzrignore	2013-05-24 17:37:52 +0000
+++ .bzrignore	2013-06-19 06:51:26 +0000
@@ -3,3 +3,5 @@
 ./build
 ./dist
 /tags
+.testrepository
+*.egg

=== added file '.testr.conf'
--- .testr.conf	1970-01-01 00:00:00 +0000
+++ .testr.conf	2013-06-19 06:51:26 +0000
@@ -0,0 +1,3 @@
+[DEFAULT]
+test_command=python -m subunit.run $IDLIST
+test_id_list_default=lava_tool.tests.test_suite

=== modified file 'ci-build'
--- ci-build	2013-06-03 20:56:10 +0000
+++ ci-build	2013-06-19 06:51:26 +0000
@@ -1,11 +1,13 @@
 #!/bin/sh
 
+VENV_DIR="/tmp/ci-build-venv"
+
 set -e
 
 if test -z "$VIRTUAL_ENV"; then
   set -x
-  virtualenv ci-build-venv
-  . ci-build-venv/bin/activate
+  virtualenv $VENV_DIR
+  . $VENV_DIR/bin/activate
   python setup.py develop
 fi
 
@@ -21,6 +23,10 @@
   pip install mocker
 fi
 
+if ! pip show mock | grep -q mock; then
+  pip install mock
+fi
+
 export LAVACONFIG=/dev/null
 
 if test -z "$DISPLAY"; then

=== modified file 'entry_points.ini'
--- entry_points.ini	2013-05-27 20:51:39 +0000
+++ entry_points.ini	2013-06-19 06:51:26 +0000
@@ -8,6 +8,7 @@
 scheduler = lava_scheduler_tool.commands:scheduler
 dashboard = lava_dashboard_tool.commands:dashboard
 job = lava.job.commands:job
+device = lava.device.commands:device
 
 [lava_tool.commands]
 help = lava.tool.commands.help:help
@@ -70,3 +71,8 @@
 new = lava.job.commands:new
 submit = lava.job.commands:submit
 run = lava.job.commands:run
+
+[lava.device.commands]
+add = lava.device.commands:add
+remove = lava.device.commands:remove
+config = lava.device.commands:config

=== modified file 'lava/config.py'
--- lava/config.py	2013-05-28 22:08:12 +0000
+++ lava/config.py	2013-06-19 06:51:26 +0000
@@ -30,14 +30,25 @@
     pass
 atexit.register(readline.write_history_file, history)
 
-config_file = os.environ.get('LAVACONFIG') or os.path.join(os.path.expanduser('~'), '.lavaconfig')
+config_file = (os.environ.get('LAVACONFIG') or
+               os.path.join(os.path.expanduser('~'), '.lavaconfig'))
 config_backend = ConfigParser()
 config_backend.read([config_file])
+
+
 def save_config():
     with open(config_file, 'w') as f:
         config_backend.write(f)
 atexit.register(save_config)
 
+
+class Parameter(object):
+
+    def __init__(self, id, depends=None):
+        self.id = id
+        self.depends = depends
+
+
 class InteractiveConfig(object):
 
     def __init__(self, force_interactive=False):

=== added directory 'lava/device'
=== added file 'lava/device/__init__.py'
--- lava/device/__init__.py	1970-01-01 00:00:00 +0000
+++ lava/device/__init__.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,124 @@
+# 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/>.
+
+import re
+
+from lava.device.templates import (
+    KNOWN_TEMPLATES,
+    DEFAULT_TEMPLATE,
+)
+from lava.tool.errors import CommandError
+
+
+def __re_compile(name):
+    """Creates a generic regex for the specified device name.
+
+    :param name: The name of the device.
+    :return A Pattern object.
+    """
+    return re.compile('^.*{0}.*'.format(name), re.I)
+
+
+# Dictionary of know devices.
+# Keys are the general device name taken from lava.device.templates, values
+# are tuples of: a regex matcher to match the device, and the device associated
+# template.
+KNOWN_DEVICES = dict([(device, (__re_compile(device), template))
+                     for device, template in KNOWN_TEMPLATES.iteritems()])
+
+
+class Device(object):
+    """A generic device."""
+    def __init__(self, hostname, template):
+        self.device_type = None
+        self.hostname = hostname
+        self.template = template.copy()
+
+    def write(self, conf_file):
+        """Writes the object to file.
+
+        :param conf_file: The full path of the file where to write."""
+        with open(conf_file, 'w') as write_file:
+            write_file.write(self.__str__())
+
+    def _update(self):
+        """Updates the template with the values specified for this class.
+
+        Subclasses need to override this when they add more specific
+        attributes.
+        """
+        # This is needed for the 'default' behavior. If we matched a known
+        # device, we do not need to update its device_type, since its already
+        # defined in the template.
+        if self.device_type:
+            self.template.update(hostname=self.hostname,
+                                 device_type=self.device_type)
+        else:
+            self.template.update(hostname=self.hostname)
+
+    def __str__(self):
+        self._update()
+        string_list = []
+        for key, value in self.template.iteritems():
+            if not value:
+                value = ''
+            string_list.append("{0} = {1}\n".format(str(key), str(value)))
+        return "".join(string_list)
+
+    def __repr__(self):
+        self._update()
+        return str(self.template)
+
+
+def _get_device_type_from_user():
+    """Makes the user write what kind of device this is.
+
+    If something goes wrong, raises CommandError.
+    """
+    try:
+        dev_type = raw_input("Please specify the device type: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        dev_type = None
+    if not dev_type:
+        raise CommandError("DEVICE name not specified or not correct.")
+    return dev_type
+
+
+def get_known_device(name):
+    """Tries to match a device name with a known device type.
+
+    :param name: The name of the device we want matched to a real device.
+    :return A Device instance.
+        """
+    instance = None
+    for known_dev, (matcher, dev_template) in KNOWN_DEVICES.iteritems():
+        if matcher.match(name):
+            instance = Device(name, dev_template)
+    if not instance:
+        dev_type = _get_device_type_from_user()
+        known_dev = KNOWN_DEVICES.get(dev_type, None)
+        if known_dev:
+            instance = Device(name, known_dev[1])
+        else:
+            print ("Device '{0}' does not match a known "
+                   "device.".format(dev_type))
+            instance = Device(name, DEFAULT_TEMPLATE)
+            # Not stricly necessary, users can fill up the field later.
+            instance.device_type = dev_type
+
+    return instance

=== added file 'lava/device/commands.py'
--- lava/device/commands.py	1970-01-01 00:00:00 +0000
+++ lava/device/commands.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,250 @@
+# 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/>.
+
+"""
+Device specific commands class.
+"""
+
+import os
+import subprocess
+import sys
+import random
+import string
+
+from lava.config import InteractiveConfig
+from lava.device import get_known_device
+from lava.tool.command import Command, 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"
+
+
+class device(CommandGroup):
+    """LAVA devices handling."""
+
+    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."""
+
+    @classmethod
+    def register_arguments(cls, parser):
+        super(add, cls).register_arguments(parser)
+        parser.add_argument("DEVICE", help="The name of the device to add.")
+
+    def invoke(self):
+        real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
+
+        if self._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()
+        device_conf_file = os.path.abspath(os.path.join(devices_path,
+                                                        real_file_name))
+
+        device = get_known_device(self.args.DEVICE)
+        device.write(device_conf_file)
+
+        print >> sys.stdout, ("Created device file '{0}' in: {1}".format(
+            real_file_name, devices_path))
+        self.edit_config_file(device_conf_file)
+
+
+class remove(BaseCommand):
+    """Removes the specified device."""
+
+    @classmethod
+    def register_arguments(cls, parser):
+        super(remove, cls).register_arguments(parser)
+        parser.add_argument("DEVICE",
+                            help="The name of the device to remove.")
+
+    def invoke(self):
+        real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
+        device_conf = self._get_device_file(real_file_name)
+
+        if device_conf:
+            try:
+                os.remove(device_conf)
+                print >> sys.stdout, ("Device configuration file '{0}' "
+                                      "removed.".format(real_file_name))
+            except OSError:
+                raise CommandError("Cannot remove file '{0}' at: {1}.".format(
+                    real_file_name, os.path.dirname(device_conf)))
+        else:
+            print >> sys.stdout, ("No device configuration file '{0}' "
+                                  "found.".format(real_file_name))
+
+
+class config(BaseCommand):
+    """Opens the specified device config file."""
+    @classmethod
+    def register_arguments(cls, parser):
+        super(config, cls).register_arguments(parser)
+        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 = self._get_device_file(real_file_name)
+        if device_conf and self.can_edit_file(device_conf):
+            self.edit_config_file(device_conf)
+        else:
+            raise CommandError("Cannot edit file '{0}' at: "
+                               "{1}.".format(real_file_name, device_conf))

=== added file 'lava/device/templates.py'
--- lava/device/templates.py	1970-01-01 00:00:00 +0000
+++ lava/device/templates.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,42 @@
+# 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/>.
+
+"""
+This is just a place where to store a template like dictionary that
+will be used to serialize a Device object.
+"""
+
+DEFAULT_TEMPLATE = {
+    'device_type': None,
+    'hostname': None,
+    'connection_command': None,
+}
+
+# Dictionary with templates of known devices.
+KNOWN_TEMPLATES = {
+    'panda': {
+        'device_type': 'panda',
+        'hostname': None,
+        'connection_command': None,
+    },
+    'vexpress': {
+        'device_type': 'vexpress',
+        'hostname': None,
+        'connection_command': None,
+    },
+}

=== added directory 'lava/device/tests'
=== added file 'lava/device/tests/__init__.py'
=== added file 'lava/device/tests/test_commands.py'
--- lava/device/tests/test_commands.py	1970-01-01 00:00:00 +0000
+++ lava/device/tests/test_commands.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,175 @@
+# 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/>.
+
+"""
+Commands class unit tests.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+
+from mock import MagicMock
+from unittest import TestCase
+
+from lava.device.commands import (
+    BaseCommand,
+    add,
+    config,
+    remove,
+)
+
+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):
+        # Tests invocation of the add command. Verifies that the conf file is
+        # written to disk.
+        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.invoke()
+
+        expected_path = os.path.join(self.tempdir,
+                                     ".".join([self.device, "conf"]))
+        self.assertTrue(os.path.isfile(expected_path))
+
+    def test_remove_invoke(self):
+        # 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.
+        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.invoke()
+
+        expected_path = os.path.join(self.tempdir,
+                                     ".".join([self.device, "conf"]))
+
+        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))
+
+    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)
+
+    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)
+
+    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)

=== added file 'lava/device/tests/test_device.py'
--- lava/device/tests/test_device.py	1970-01-01 00:00:00 +0000
+++ lava/device/tests/test_device.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,123 @@
+# 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/>.
+
+"""
+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)
+
+    def test_get_known_device_panda_0(self):
+        # User creates a new device with a guessable name for a device.
+        instance = get_known_device('panda_new_01')
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template['device_type'], 'panda')
+        self.assertIsNone(instance.device_type)
+
+    def test_get_known_device_panda_1(self):
+        # User creates a new device with a guessable name for a device.
+        # Name passed has capital letters.
+        instance = get_known_device('new_PanDa_02')
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template['device_type'], 'panda')
+        self.assertIsNone(instance.device_type)
+
+    def test_get_known_device_vexpress_0(self):
+        # User creates a new device with a guessable name for a device.
+        # Name passed has capital letters.
+        instance = get_known_device('a_VexPress_Device')
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template['device_type'], 'vexpress')
+        self.assertIsNone(instance.device_type)
+
+    def test_get_known_device_vexpress_1(self):
+        # User creates a new device with a guessable name for a device.
+        instance = get_known_device('another-vexpress')
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template['device_type'], 'vexpress')
+        self.assertIsNone(instance.device_type)
+
+    def test_instance_update(self):
+        # Tests that when calling the _update() function with an known device
+        # it does not update the device_type instance attribute, and that the
+        # template contains the correct name.
+        instance = get_known_device('Another_PanDa_device')
+        instance._update()
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template['device_type'], 'panda')
+        self.assertIsNone(instance.device_type)
+
+    def test_get_known_device_unknown(self):
+        # User tries to create a new device with an unknown device type. She
+        # is asked to insert the device type and types 'a_fake_device'.
+        sys.stdin = StringIO('a_fake_device')
+        instance = get_known_device('a_fake_device')
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.device_type, 'a_fake_device')
+
+    def test_get_known_device_known(self):
+        # User tries to create a new device with a not recognizable name.
+        # She is asked to insert the device type and types 'panda'.
+        sys.stdin = StringIO("panda")
+        instance = get_known_device("another_fake_device")
+        self.assertIsInstance(instance, Device)
+        self.assertEqual(instance.template["device_type"], "panda")
+
+    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.
+        self.assertRaises(CommandError, get_known_device, 'a_fake_device')
+
+    def test_device_write(self):
+        # User tries to create a new panda device. The conf file is written
+        # and contains the expected results.
+        expected = ("hostname = panda02\nconnection_command = \n"
+                    "device_type = panda\n")
+        instance = get_known_device("panda02")
+        instance.write(self.temp_file.name)
+        obtained = ""
+        with open(self.temp_file.name) as f:
+            obtained = f.read()
+        self.assertEqual(expected, obtained)

=== modified file 'lava/job/templates.py'
--- lava/job/templates.py	2013-05-28 22:08:12 +0000
+++ lava/job/templates.py	2013-06-19 06:51:26 +0000
@@ -16,11 +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/>.
 
-class Parameter(object):
-
-    def __init__(self, id, depends=None):
-        self.id = id
-        self.depends = depends
+from lava.config import Parameter
 
 device_type = Parameter("device_type")
 prebuilt_image = Parameter("prebuilt_image", depends=device_type)

=== modified file 'lava_tool/tests/__init__.py'
--- lava_tool/tests/__init__.py	2013-05-27 20:51:39 +0000
+++ lava_tool/tests/__init__.py	2013-06-19 06:51:26 +0000
@@ -26,22 +26,24 @@
 
 def app_modules():
     return [
-            'lava_tool.commands',
-            'lava_tool.dispatcher',
-            'lava_tool.interface',
-            'lava_dashboard_tool.commands',
-            ]
+        'lava_tool.commands',
+        'lava_tool.dispatcher',
+        'lava_tool.interface',
+        'lava_dashboard_tool.commands',
+    ]
 
 
 def test_modules():
     return [
-            'lava_tool.tests.test_authtoken',
-            'lava_tool.tests.test_auth_commands',
-            'lava_tool.tests.test_commands',
-            'lava_dashboard_tool.tests.test_commands',
-            'lava.job.tests.test_job',
-            'lava.job.tests.test_commands',
-            ]
+        'lava_tool.tests.test_authtoken',
+        'lava_tool.tests.test_auth_commands',
+        'lava_tool.tests.test_commands',
+        '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',
+    ]
 
 
 def test_suite():
@@ -52,6 +54,7 @@
     modules = app_modules() + test_modules()
     suite = unittest.TestSuite()
     loader = unittest.TestLoader()
+
     for name in modules:
         unit_suite = loader.loadTestsFromName(name)
         suite.addTests(unit_suite)

=== modified file 'lava_tool/tests/test_authtoken.py'
--- lava_tool/tests/test_authtoken.py	2013-05-22 13:45:44 +0000
+++ lava_tool/tests/test_authtoken.py	2013-06-19 06:51:26 +0000
@@ -24,7 +24,6 @@
 import StringIO
 from unittest import TestCase
 import urlparse
-import sys
 import xmlrpclib
 
 from mocker import ARGS, KWARGS, Mocker

=== added file 'lava_tool/utils.py'
--- lava_tool/utils.py	1970-01-01 00:00:00 +0000
+++ lava_tool/utils.py	2013-06-19 06:51:26 +0000
@@ -0,0 +1,33 @@
+# 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/>.
+
+import subprocess
+
+
+def has_command(command):
+    """Checks that the given command is available.
+
+    :param command: The name of the command to check availability.
+    """
+    command_available = True
+    try:
+        subprocess.check_call(["which", command],
+                              stdout=open('/dev/null', 'w'))
+    except subprocess.CalledProcessError:
+        command_available = False
+    return command_available

=== modified file 'setup.py'
--- setup.py	2013-05-17 19:21:51 +0000
+++ setup.py	2013-06-19 06:51:26 +0000
@@ -53,5 +53,8 @@
         'versiontools >= 1.3.1'
     ],
     setup_requires=['versiontools >= 1.3.1'],
-    tests_require=['mocker >= 1.0'],
+    tests_require=[
+        'mocker >= 1.0',
+        'mock >= 0.7.2'
+    ],
     zip_safe=True)