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

[Milo Casagrande]

This new branch addresses some of the concerns raised while reviewing lp:~milo/lava-tool/lava-168.
It is in a separate branch since the previous merge proposal was already quite big.

* Refactored the Config class: now there are a generic Config class with most of the logic to store values, and an InteractiveConfig class that overrides only a subset of methods from Config in order to handle user input.
* The Parameter class has been refactored and moved into its own file. Two new attributes have been added: 'value', mostly needed for the Device templates; 'asked', needed when using the InteractiveConfig class in order not to ask twice the same parameter value.
* Tests have been added and old ones refactored.

[lp:~milo/lava-tool/device-parameters]

226. By Milo Casagrande on 2013-06-21

Refactored constructor.

227. By Milo Casagrande on 2013-06-21

Fixed the device templates.

    * Needed to specialized some of the template parameters due to
      object references.

228. By Milo Casagrande on 2013-06-21

Fixed the Config classes.

    * Parameter values can also be empty.
    * If the user presses Enter with an old value, keep the old value,
      otherwise value will be empty.

229. By Milo Casagrande on 2013-06-21

Fixed tests.

230. By Milo Casagrande on 2013-06-21

Added two more tests.

[Antonio Terceiro (terceiro)]

Hi Milo,

Thanks for your efforts with this. I am amazed by the amount of tests you have
been adding. :-)

I have some comments below

 review needs-fixing

> === added file 'HACKING'
> --- HACKING 1970-01-01 00:00:00 +0000
> +++ HACKING 2013-06-20 15:51:34 +0000
> @@ -0,0 +1,17 @@
> +Tests Code Coverage
> +===================
> +
> +To have a nicely HTML viewable report on tests code coverage, do as follows:
> +
> +* Install `python-coverage` (`pip install coverage` in case you use pip)
> +* Run the following command:
> +
> + python-coverage run -m unittest lava_tool.tests.test_suite 2>/dev/null && python-coverage html
> +
> +* The report will be save in a directory called `lava_tool_coverage`: open

typo: save → saved

> +the `index.html` file in there to see the report.
> +
> +Notes:
> +
> + * To re-run the coverage report, you have to delete the `lava_tool_coverage`
> +directory first, otherwise `python-coverage` will fail.
>
> === modified file 'lava/config.py'
> --- lava/config.py 2013-06-20 15:51:34 +0000
> +++ lava/config.py 2013-06-20 15:51:34 +0000
> @@ -16,91 +16,224 @@
> # 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/>.
>
> +"""
> +Config class.
> +"""
> +
> import atexit
> -from ConfigParser import ConfigParser, NoOptionError, NoSectionError
> import os
> import readline
> -
> -__all__ = ['InteractiveConfig', 'NonInteractiveConfig']
> -
> -history = os.path.join(os.path.expanduser("~"), ".lava_history")
> +import sys
> +
> +
> +from ConfigParser import ConfigParser, NoOptionError, NoSectionError
> +
> +__all__ = ['Config', 'InteractiveConfig']
> +
> +# Store for function calls to be made at exit time.
> +AT_EXIT_CALLS = set()
> +# Config default section.
> +DEFAULT_SECTION = "DEFAULT"
> +
> +HISTORY = os.path.join(os.path.expanduser("~"), ".lava_history")
> try:
> - readline.read_history_file(history)
> + readline.read_history_file(HISTORY)
> except IOError:
> pass
> -atexit.register(readline.write_history_file, history)
> -
> -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):
> - self._force_interactive = force_interactive
> +atexit.register(readline.write_history_file, HISTORY)
> +
> +
> +def _run_at_exit():
> + """Runs all the function at exit."""
> + for call in list(AT_EXIT_CALLS):
> + call()
> +atexit.register(_run_at_exit)
> +
> +
> +class Config(object):
> + """A generic config object."""
> + def __init__(self):
> + # The cache where to store parameters.
> self._cache = {}
> -
> - def get(self, parameter):
> - key = parameter.id
> - ...

review: Needs Fixing

[lp:~milo/lava-tool/device-parameters]

231. By Milo Casagrande on 2013-06-25

Fixed typos.

[Milo Casagrande (milo)]

Hello Antonio!

Thanks for going through this!

On Fri, Jun 21, 2013 at 1:40 PM, Antonio Terceiro
<email address hidden> wrote:
>
>> +class InteractiveConfig(Config):
>> + """An interactive config.
>> +
>> + If a value is not found in the config file, it will ask it and then stores
>> + it.
>> + """
>> + def __init__(self, force_interactive=True):
>> + super(InteractiveConfig, self).__init__()
>> + self._force_interactive = force_interactive
>> +
>> + def _calculate_config_section(self, parameter):
>> + """Calculates the config section of the specified parameter.
>> +
>> + :param parameter: The parameter to calculate the section of.
>> + :type Parameter
>> + :return The config section.
>> + """
>> + section = DEFAULT_SECTION
>> + if parameter.depends:
>> + # This is mostly relevant to the InteractiveConfig class.
>> + # If a parameter has a dependency we do as follows:
>> + # - Get the dependency cached value
>> + # - Get the dependency value from the config file
>> + # - If both are None, it means the dependency has not been inserted
>> + # yet, and we ask for it.
>
> I have the impression that just calling get() would already to this.
>
>> + depend_section = self._calculate_config_section(parameter.depends)
>> +
>> + cached_value = self._get_from_cache(parameter.depends,
>> + depend_section)
>> + config_value = self._get_from_backend(parameter.depends,
>> + depend_section)
>> +
>> + # Honor the cached value.
>> + value = cached_value or config_value
>> + if not value:
>> + value = self.get(parameter.depends)
>> + parameter.depends.asked = True
>> + section = "{0}={1}".format(parameter.depends.id, value)
>> + return section
>
> Also, I don't understand why you need to override this method. I can't see why
> the logic for determining the section to write a config entry to would be
> different on interactive config wrt to plain config - as long as get() does the
> right thing.

Yeah, this is something I forgot to remove.
I had a problem in the device template and how I was "copying" the
default template, and when trying to figure out what was happening, I
override that method.
The two gets (from cache and config) were done to avoid multiple calls
to the _calculate_config_section method (that is why I added the
section parameter to get()).

>> -
>> - def _update(self):
>> - """Updates the template with the values specified for this class.
>> -
>> - Subclasses need to override this when they add more specific
>> - attributes.
>> + write_file.write(str(self))
>> +
>> + def update(self, config):
>> + """Updates the Device object values based on the provided config.
>> +
>> + :param config: A Config instance.
>> """
>> - # This is needed for the 'default' behavior. If we matched a known
>> - # device, we do not need...

[lp:~milo/lava-tool/device-parameters]

232. By Milo Casagrande on 2013-06-25

Use copy instead of deepcopy.

    * Used copy instead of deepcopy to avoid wrong references
      when updating the template.

233. By Milo Casagrande on 2013-06-25

Removed overridden method.

    * The overridden method is not necessary.

234. By Milo Casagrande on 2013-06-25

Fixed typo and refactore function name.

235. By Milo Casagrande on 2013-06-25

Removed not necessary test.

236. By Milo Casagrande on 2013-06-25

Refactored where user input is taken.

    * Moved raw_input logic from the Config into the Parameter.
    * Fixed old tests.
    * Added new test class for the Parameter class.

237. By Milo Casagrande on 2013-06-25

Fixed how the prompt is built.

238. By Milo Casagrande on 2013-06-25

Merged missing commit.

239. By Milo Casagrande on 2013-06-25

Readded asked attribute.

240. By Milo Casagrande on 2013-06-26

Refactored the expand_template function.

    * Created a helper module for template.
    * Moved the expand_template function in the new module.
    * Updated lava job command to use the new helper function.

241. By Milo Casagrande on 2013-06-26

Removed unused import statement.

242. By Milo Casagrande on 2013-06-26

Added two more tests for the dispatcher helper functions.

243. By Milo Casagrande on 2013-06-26

Fixed list creation.

244. By Milo Casagrande on 2013-06-26

Added more tests for the helper command functions.

245. By Milo Casagrande on 2013-06-26

Fixed file test.

246. By Milo Casagrande on 2013-06-26

Added more tests to the device commands.

247. By Milo Casagrande on 2013-06-26

Added one more test for device commands.

248. By Milo Casagrande on 2013-06-27

Fixed import.

=== modified file '.bzrignore'
--- .bzrignore	2013-06-27 12:48:26 +0000
+++ .bzrignore	2013-06-27 12:48:26 +0000
@@ -5,3 +5,4 @@
 /tags
 .testrepository
 *.egg
+lava_tool_coverage

=== added file '.coveragerc'
--- .coveragerc	1970-01-01 00:00:00 +0000
+++ .coveragerc	2013-06-27 12:48:26 +0000
@@ -0,0 +1,13 @@
+[run]
+branch = True
+source = .
+omit =
+    setup*
+
+[report]
+precision = 2
+show_missing = True
+
+[html]
+title = Code Coverage of lava-tool
+directory = lava_tool_coverage

=== added file 'HACKING'
--- HACKING	1970-01-01 00:00:00 +0000
+++ HACKING	2013-06-27 12:48:26 +0000
@@ -0,0 +1,17 @@
+Tests Code Coverage
+===================
+
+To have a nicely HTML viewable report on tests code coverage, do as follows:
+
+* Install `python-coverage` (`pip install coverage` in case you use pip)
+* Run the following command:
+
+    python-coverage run -m unittest lava_tool.tests.test_suite 2>/dev/null && python-coverage html
+
+* The report will be saved in a directory called `lava_tool_coverage`: open 
+the `index.html` file in there to see the report.
+
+Notes:
+
+ * To re-run the coverage report, you have to delete the `lava_tool_coverage`
+directory first, otherwise `python-coverage` will fail.

=== modified file 'ci-build'
--- ci-build	2013-06-27 12:48:26 +0000
+++ ci-build	2013-06-27 12:48:26 +0000
@@ -1,6 +1,8 @@
 #!/bin/sh
 
 VENV_DIR="/tmp/ci-build-venv"
+# Directory where coverage HTML report will be written.
+COVERAGE_REPORT_DIR="lava_tool_coverage"
 
 set -e
 
@@ -26,6 +28,10 @@
 if ! pip show mock | grep -q mock; then
   pip install mock
 fi
+# Requirement to run code coverage tests.
+if ! pip show coverage | grep -q coverage; then
+  pip install coverage
+fi
 
 export LAVACONFIG=/dev/null
 
@@ -45,4 +51,10 @@
   python -m unittest lava_tool.tests.test_suite < /dev/null
 fi
 
+if test -d $COVERAGE_REPORT_DIR; then
+  rm -rf $COVERAGE_REPORT_DIR
+fi
+# Runs python-coverage.
+python-coverage run -m unittest lava_tool.tests.test_suite 2>/dev/null && python-coverage html
+
 ./integration-tests

=== modified file 'lava/config.py'
--- lava/config.py	2013-06-27 12:48:26 +0000
+++ lava/config.py	2013-06-27 12:48:26 +0000
@@ -16,91 +16,192 @@
 # 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/>.
 
+"""
+Config class.
+"""
+
 import atexit
-from ConfigParser import ConfigParser, NoOptionError, NoSectionError
 import os
 import readline
 
-__all__ = ['InteractiveConfig', 'NonInteractiveConfig']
-
-history = os.path.join(os.path.expanduser("~"), ".lava_history")
+from ConfigParser import (
+    ConfigParser,
+    NoOptionError,
+    NoSectionError,
+)
+
+from lava.tool.errors import CommandError
+
+__all__ = ['Config', 'InteractiveConfig']
+
+# Store for function calls to be made at exit time.
+AT_EXIT_CALLS = set()
+# Config default section.
+DEFAULT_SECTION = "DEFAULT"
+
+HISTORY = os.path.join(os.path.expanduser("~"), ".lava_history")
 try:
-    readline.read_history_file(history)
+    readline.read_history_file(HISTORY)
 except IOError:
     pass
-atexit.register(readline.write_history_file, history)
-
-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):
-        self._force_interactive = force_interactive
+atexit.register(readline.write_history_file, HISTORY)
+
+
+def _run_at_exit():
+    """Runs all the function at exit."""
+    for call in list(AT_EXIT_CALLS):
+        call()
+atexit.register(_run_at_exit)
+
+
+class Config(object):
+    """A generic config object."""
+    def __init__(self):
+        # The cache where to store parameters.
         self._cache = {}
-
-    def get(self, parameter):
-        key = parameter.id
-        value = None
+        self._config_file = (os.environ.get('LAVACONFIG') or
+                             os.path.join(os.path.expanduser('~'),
+                                          '.lavaconfig'))
+        self._config_backend = ConfigParser()
+        self._config_backend.read([self._config_file])
+        AT_EXIT_CALLS.add(self.save)
+
+    def _calculate_config_section(self, parameter):
+        """Calculates the config section of the specified parameter.
+
+        :param parameter: The parameter to calculate the section of.
+        :type Parameter
+        :return The config section.
+        """
+        section = DEFAULT_SECTION
         if parameter.depends:
-            pass
-            config_section = parameter.depends.id + '=' + self.get(parameter.depends)
+            section = "{0}={1}".format(parameter.depends.id,
+                                       self.get(parameter.depends))
+        return section
+
+    def get(self, parameter, section=None):
+        """Retrieves a Parameter value.
+
+        The value is taken either from the Parameter itself, or from the cache,
+        or from the config file.
+
+        :param parameter: The parameter to search.
+        :type Parameter
+        :return The parameter value, or None if it is not found.
+        """
+        if not section:
+            section = self._calculate_config_section(parameter)
+        # Try to get the parameter value first if it has one.
+        if parameter.value:
+            value = parameter.value
         else:
-            config_section = "DEFAULT"
-
-        if config_section in self._cache:
-            if key in self._cache[config_section]:
-                return self._cache[config_section][key]
-
-        prompt = '%s: ' % key
-
+            value = self._get_from_cache(parameter, section)
+
+        if value is None:
+            value = self._get_from_backend(parameter, section)
+        return value
+
+    def _get_from_backend(self, parameter, section):
+        """Gets the parameter value from the config backend.
+
+        :param parameter: The Parameter to look up.
+        :param section: The section in the Config.
+        """
+        value = None
         try:
-            value = config_backend.get(config_section, key)
+            value = self._config_backend.get(section, parameter.id)
         except (NoOptionError, NoSectionError):
+            # Ignore, we return None.
             pass
-        if value:
-            if self._force_interactive:
-                prompt = "%s[%s]: " % (key, value)
-            else:
-                return value
-        try:
-            user_input = raw_input(prompt).strip()
-        except EOFError:
-            user_input = None
-        if user_input:
-            value = user_input
-            if not config_backend.has_section(config_section) and config_section != 'DEFAULT':
-                config_backend.add_section(config_section)
-            config_backend.set(config_section, key, value)
-
-        if value:
-            if config_section not in self._cache:
-                self._cache[config_section] = {}
-            self._cache[config_section][key] = value
-            return value
-        else:
-            raise KeyError(key)
-
-class NonInteractiveConfig(object):
-
-    def __init__(self, data):
-        self.data = data
-
-    def get(self, parameter):
-        return self.data[parameter.id]
+        return value
+
+    def _get_from_cache(self, parameter, section):
+        """Looks for the specified parameter in the internal cache.
+
+        :param parameter: The parameter to search.
+        :type Parameter
+        :return The parameter value, of None if it is not found.
+        """
+        value = None
+        if section in self._cache.keys():
+            if parameter.id in self._cache[section].keys():
+                value = self._cache[section][parameter.id]
+        return value
+
+    def _put_in_cache(self, key, value, section=DEFAULT_SECTION):
+        """Insert the passed parameter in the internal cache.
+
+        :param parameter: The parameter to insert.
+        :type Parameter
+        :param section: The name of the section in the config file.
+        :type str
+        """
+        if section not in self._cache.keys():
+            self._cache[section] = {}
+        self._cache[section][key] = value
+
+    def put(self, key, value, section=DEFAULT_SECTION):
+        """Adds a parameter to the config file.
+
+        :param key: The key to add.
+        :param value: The value to add.
+        :param section: The name of the section as in the config file.
+        """
+        if (not self._config_backend.has_section(section) and
+                section != DEFAULT_SECTION):
+            self._config_backend.add_section(section)
+        self._config_backend.set(section, key, value)
+        # Store in the cache too.
+        self._put_in_cache(key, value, section)
+
+    def put_parameter(self, parameter, value=None, section=None):
+        """Adds a Parameter to the config file and cache.
+
+        :param Parameter: The parameter to add.
+        :param value: The value of the parameter. Defaults to None.
+        :param section: The section where this parameter should be stored.
+                        Defaults to None.
+        """
+        if not section:
+            section = self._calculate_config_section(parameter)
+
+        if value is None and parameter.value is not None:
+            value = parameter.value
+        elif value is None:
+            raise CommandError("No value assigned to '{0}'.".format(
+                parameter.id))
+        self.put(parameter.id, value, section)
+
+    def save(self):
+        """Saves the config to file."""
+        with open(self._config_file, "w") as write_file:
+            self._config_backend.write(write_file)
+
+
+class InteractiveConfig(Config):
+    """An interactive config.
+
+    If a value is not found in the config file, it will ask it and then stores
+    it.
+    """
+    def __init__(self, force_interactive=True):
+        super(InteractiveConfig, self).__init__()
+        self._force_interactive = force_interactive
+
+    def get(self, parameter, section=None):
+        """Overrides the parent one.
+
+        The only difference with the parent one, is that it will ask to type
+        a parameter value in case it is not found.
+        """
+        if not section:
+            section = self._calculate_config_section(parameter)
+        value = super(InteractiveConfig, self).get(parameter, section)
+
+        if not (value is not None and parameter.asked):
+            if not value or self._force_interactive:
+                value = parameter.prompt(old_value=value)
+
+        if value is not None:
+            self.put(parameter.id, value, section)
+        return value

=== modified file 'lava/device/__init__.py'
--- lava/device/__init__.py	2013-06-27 12:48:26 +0000
+++ lava/device/__init__.py	2013-06-27 12:48:26 +0000
@@ -18,11 +18,14 @@
 
 import re
 
+from copy import deepcopy
+
 from lava.device.templates import (
+    DEFAULT_TEMPLATE,
+    HOSTNAME_PARAMETER,
     KNOWN_TEMPLATES,
-    DEFAULT_TEMPLATE,
 )
-from lava.tool.errors import CommandError
+from lava.helper.template import expand_template
 
 
 def __re_compile(name):
@@ -44,60 +47,37 @@
 
 class Device(object):
     """A generic device."""
-    def __init__(self, hostname, template):
-        self.device_type = None
+    def __init__(self, template, hostname=None):
+        self.data = deepcopy(template)
         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.
+            write_file.write(str(self))
+
+    def update(self, config):
+        """Updates the Device object values based on the provided config.
+
+        :param config: A Config instance.
         """
-        # 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)
+        # We should always have a hostname, since it defaults to the name
+        # given on the command line for the config file.
+        if self.hostname is not None:
+            # We do not ask the user again this parameter.
+            self.data[HOSTNAME_PARAMETER.id].asked = True
+            config.put(HOSTNAME_PARAMETER.id, self.hostname)
+
+        expand_template(self.data, config)
 
     def __str__(self):
-        self._update()
         string_list = []
-        for key, value in self.template.iteritems():
-            if not value:
-                value = ''
+        for key, value in self.data.iteritems():
             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.
@@ -105,20 +85,9 @@
     :param name: The name of the device we want matched to a real device.
     :return A Device instance.
         """
-    instance = None
+    instance = Device(DEFAULT_TEMPLATE, name)
     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
-
+            instance = Device(dev_template, name)
+            break
     return instance

=== modified file 'lava/device/commands.py'
--- lava/device/commands.py	2013-06-27 12:48:26 +0000
+++ lava/device/commands.py	2013-06-27 12:48:26 +0000
@@ -56,7 +56,7 @@
     def invoke(self):
         real_file_name = ".".join([self.args.DEVICE, DEVICE_FILE_SUFFIX])
 
-        if get_device_file(real_file_name):
+        if get_device_file(real_file_name) is not None:
             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 "
@@ -68,6 +68,7 @@
                                                         real_file_name))
 
         device = get_known_device(self.args.DEVICE)
+        device.update(self.config)
         device.write(device_conf_file)
 
         print >> sys.stdout, ("Created device file '{0}' in: {1}".format(
@@ -116,5 +117,4 @@
         if device_conf and self.can_edit_file(device_conf):
             self.edit_file(device_conf)
         else:
-            raise CommandError("Cannot edit file '{0}' at: "
-                               "{1}.".format(real_file_name, device_conf))
+            raise CommandError("Cannot edit file '{0}'".format(real_file_name))

=== modified file 'lava/device/templates.py'
--- lava/device/templates.py	2013-06-27 12:48:26 +0000
+++ lava/device/templates.py	2013-06-27 12:48:26 +0000
@@ -21,22 +21,50 @@
 will be used to serialize a Device object.
 """
 
+from copy import copy
+
+from lava.parameter import Parameter
+
+# The hostname parameter is always in the DEFAULT config section.
+HOSTNAME_PARAMETER = Parameter("hostname")
+DEVICE_TYPE_PARAMETER = Parameter("device_type", depends=HOSTNAME_PARAMETER)
+CONNECTION_COMMAND_PARMAETER = Parameter("connection_command",
+                                         depends=DEVICE_TYPE_PARAMETER)
+
 DEFAULT_TEMPLATE = {
-    'device_type': None,
-    'hostname': None,
-    'connection_command': None,
+    'hostname': HOSTNAME_PARAMETER,
+    'device_type': DEVICE_TYPE_PARAMETER,
+    'connection_command': CONNECTION_COMMAND_PARMAETER,
 }
 
+# Specialized copies of the parameters.
+# We need this or we might end up asking the user twice the same parameter due
+# to different object references when one Parameter depends on a "specialized"
+# one, different from the defaults.
+PANDA_DEVICE_TYPE = copy(DEVICE_TYPE_PARAMETER)
+PANDA_DEVICE_TYPE.value = "panda"
+PANDA_DEVICE_TYPE.asked = True
+
+PANDA_CONNECTION_COMMAND = copy(CONNECTION_COMMAND_PARMAETER)
+PANDA_CONNECTION_COMMAND.depends = PANDA_DEVICE_TYPE
+
+VEXPRESS_DEVICE_TYPE = copy(DEVICE_TYPE_PARAMETER)
+VEXPRESS_DEVICE_TYPE.value = "vexpress"
+VEXPRESS_DEVICE_TYPE.asked = True
+
+VEXPRESS_CONNECTION_COMMAND = copy(CONNECTION_COMMAND_PARMAETER)
+VEXPRESS_CONNECTION_COMMAND.depends = VEXPRESS_DEVICE_TYPE
+
 # Dictionary with templates of known devices.
 KNOWN_TEMPLATES = {
     'panda': {
-        'device_type': 'panda',
-        'hostname': None,
-        'connection_command': None,
+        'hostname': HOSTNAME_PARAMETER,
+        'device_type': PANDA_DEVICE_TYPE,
+        'connection_command': PANDA_CONNECTION_COMMAND,
     },
     'vexpress': {
-        'device_type': 'vexpress',
-        'hostname': None,
-        'connection_command': None,
+        'hostname': HOSTNAME_PARAMETER,
+        'device_type': VEXPRESS_DEVICE_TYPE,
+        'connection_command': VEXPRESS_CONNECTION_COMMAND,
     },
 }

=== modified file 'lava/device/tests/test_commands.py'
--- lava/device/tests/test_commands.py	2013-06-27 12:48:26 +0000
+++ lava/device/tests/test_commands.py	2013-06-27 12:48:26 +0000
@@ -22,7 +22,11 @@
 
 import os
 
-from mock import MagicMock, patch
+from mock import (
+    MagicMock,
+    call,
+    patch,
+)
 
 from lava.device.commands import (
     add,
@@ -33,12 +37,25 @@
 from lava.tool.errors import CommandError
 
 
-class CommandsTest(HelperTest):
-
+class AddCommandTest(HelperTest):
+
+    def test_register_argument(self):
+        # Make sure that the parser add_argument is called and we have the
+        # correct argument.
+        add_command = add(self.parser, self.args)
+        add_command.register_arguments(self.parser)
+        name, args, kwargs = self.parser.method_calls[0]
+        self.assertIn("--non-interactive", args)
+
+        name, args, kwargs = self.parser.method_calls[1]
+        self.assertIn("DEVICE", args)
+
+    @patch("lava.device.Device.__str__", new=MagicMock(return_value=""))
+    @patch("lava.device.Device.update", new=MagicMock())
     @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):
+    def test_add_invoke_0(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
@@ -51,6 +68,37 @@
                                      ".".join([self.device, "conf"]))
         self.assertTrue(os.path.isfile(expected_path))
 
+    @patch("lava.device.commands.get_known_device")
+    @patch("lava.device.commands.get_devices_path")
+    @patch("lava.device.commands.sys.exit")
+    @patch("lava.device.commands.get_device_file")
+    def test_add_invoke_1(self, mocked_get_device_file, mocked_sys_exit,
+                          mocked_get_devices_path, mocked_get_known_device):
+        mocked_get_devices_path.return_value = self.temp_dir
+        mocked_get_device_file.return_value = self.temp_file.name
+
+        add_command = add(self.parser, self.args)
+        add_command.edit_file = MagicMock()
+        add_command.invoke()
+
+        self.assertTrue(mocked_sys_exit.called)
+
+
+class RemoveCommandTests(HelperTest):
+
+    def test_register_argument(self):
+        # Make sure that the parser add_argument is called and we have the
+        # correct argument.
+        command = remove(self.parser, self.args)
+        command.register_arguments(self.parser)
+        name, args, kwargs = self.parser.method_calls[0]
+        self.assertIn("--non-interactive", args)
+
+        name, args, kwargs = self.parser.method_calls[1]
+        self.assertIn("DEVICE", args)
+
+    @patch("lava.device.Device.__str__", new=MagicMock(return_value=""))
+    @patch("lava.device.Device.update", new=MagicMock())
     @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):
@@ -83,6 +131,33 @@
         remove_command = remove(self.parser, self.args)
         self.assertRaises(CommandError, remove_command.invoke)
 
+
+class ConfigCommanTests(HelperTest):
+
+    def test_register_argument(self):
+        # Make sure that the parser add_argument is called and we have the
+        # correct argument.
+        command = config(self.parser, self.args)
+        command.register_arguments(self.parser)
+        name, args, kwargs = self.parser.method_calls[0]
+        self.assertIn("--non-interactive", args)
+
+        name, args, kwargs = self.parser.method_calls[1]
+        self.assertIn("DEVICE", args)
+
+    @patch("lava.device.commands.get_device_file")
+    def test_config_invoke_0(self, mocked_get_device_file):
+        command = config(self.parser, self.args)
+
+        mocked_get_device_file.return_value = self.temp_file.name
+        command.can_edit_file = MagicMock(return_value=True)
+        command.edit_file = MagicMock()
+        command.invoke()
+
+        self.assertTrue(command.edit_file.called)
+        self.assertEqual([call(self.temp_file.name)],
+                         command.edit_file.call_args_list)
+
     @patch("lava.device.commands.get_device_file",
            new=MagicMock(return_value=None))
     def test_config_invoke_raises_0(self):

=== modified file 'lava/device/tests/test_device.py'
--- lava/device/tests/test_device.py	2013-06-27 12:48:26 +0000
+++ lava/device/tests/test_device.py	2013-06-27 12:48:26 +0000
@@ -20,10 +20,13 @@
 Device class unit tests.
 """
 
-import sys
-
-from StringIO import StringIO
-
+from lava.parameter import Parameter
+from lava.device.templates import (
+    HOSTNAME_PARAMETER,
+    PANDA_DEVICE_TYPE,
+    PANDA_CONNECTION_COMMAND,
+)
+from lava.tests.test_config import MockedConfig
 from lava.device import (
     Device,
     get_known_device,
@@ -38,70 +41,73 @@
         # 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)
+        self.assertEqual(instance.data['device_type'].value, 'panda')
 
     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)
+        self.assertEqual(instance.data['device_type'].value, 'panda')
 
     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)
+        self.assertEqual(instance.data['device_type'].value, 'vexpress')
 
     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')
+        self.assertIsInstance(instance.data['device_type'], Parameter)
+        self.assertEqual(instance.data['device_type'].value, 'vexpress')
+
+    def test_device_update_1(self):
+        # Tests that when calling update() on a Device, the template gets
+        # updated with the correct values from a Config instance.
+        hostname = "panda_device"
+
+        config = MockedConfig(self.temp_file.name)
+        config.put_parameter(HOSTNAME_PARAMETER, hostname)
+        config.put_parameter(PANDA_DEVICE_TYPE, "panda")
+        config.put_parameter(PANDA_CONNECTION_COMMAND, "test")
+
+        expected = {
+            "hostname": hostname,
+            "device_type": "panda",
+            "connection_command": "test"
+        }
+
+        instance = get_known_device(hostname)
+        instance.update(config)
+
+        self.assertEqual(expected, instance.data)
 
     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"
+        hostname = "panda_device"
+
+        config = MockedConfig(self.temp_file.name)
+        config.put_parameter(HOSTNAME_PARAMETER, hostname)
+        config.put_parameter(PANDA_DEVICE_TYPE, "panda")
+        config.put_parameter(PANDA_CONNECTION_COMMAND, "test")
+
+        expected = {
+            "hostname": hostname,
+            "device_type": "panda",
+            "connection_command": "test"
+        }
+
+        instance = get_known_device(hostname)
+        instance.update(config)
+        instance.write(self.temp_file.name)
+
+        expected = ("hostname = panda_device\nconnection_command = test\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()

=== modified file 'lava/helper/command.py'
--- lava/helper/command.py	2013-06-27 12:48:26 +0000
+++ lava/helper/command.py	2013-06-27 12:48:26 +0000
@@ -93,7 +93,7 @@
         :return The command execution return code.
         """
         if not isinstance(cmd_args, list):
-            cmd_args = list(cmd_args)
+            cmd_args = [cmd_args]
         try:
             return subprocess.check_call(cmd_args)
         except subprocess.CalledProcessError:

=== added file 'lava/helper/template.py'
--- lava/helper/template.py	1970-01-01 00:00:00 +0000
+++ lava/helper/template.py	2013-06-27 12:48:26 +0000
@@ -0,0 +1,44 @@
+# 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/>.
+
+from lava.parameter import Parameter
+
+
+def expand_template(template, config):
+    """Updates a template based on the values from the provided config.
+
+    :param template: A template to be updated.
+    :param config: A Config instance where values should be taken.
+    """
+
+    def update(data):
+        """Internal recursive function."""
+        if isinstance(data, dict):
+            keys = data.keys()
+        elif isinstance(data, list):
+            keys = range(len(data))
+        else:
+            return
+        for key in keys:
+            entry = data[key]
+            if isinstance(entry, Parameter):
+                data[key] = config.get(entry)
+            else:
+                update(entry)
+
+    update(template)

=== modified file 'lava/helper/tests/test_command.py'
--- lava/helper/tests/test_command.py	2013-06-27 12:48:26 +0000
+++ lava/helper/tests/test_command.py	2013-06-27 12:48:26 +0000
@@ -18,6 +18,14 @@
 
 """lava.herlp.command module tests."""
 
+import subprocess
+from mock import (
+    MagicMock,
+    call,
+    patch,
+)
+
+from lava.tool.errors import CommandError
 from lava.helper.command import BaseCommand
 from lava.helper.tests.helper_test import HelperTest
 
@@ -51,3 +59,65 @@
             obtained = f.read()
 
         self.assertEqual(expected, obtained)
+
+    @patch("lava.helper.command.subprocess")
+    def test_run_0(self, mocked_subprocess):
+        mocked_subprocess.check_call = MagicMock()
+        BaseCommand.run("foo")
+        self.assertEqual(mocked_subprocess.check_call.call_args_list,
+                         [call(["foo"])])
+        self.assertTrue(mocked_subprocess.check_call.called)
+
+    @patch("lava.helper.command.subprocess.check_call")
+    def test_run_1(self, mocked_check_call):
+        mocked_check_call.side_effect = subprocess.CalledProcessError(1, "foo")
+        self.assertRaises(CommandError, BaseCommand.run, ["foo"])
+
+    @patch("lava.helper.command.subprocess")
+    @patch("lava.helper.command.has_command", return_value=False)
+    @patch("lava.helper.command.os.environ.get", return_value=None)
+    @patch("lava.helper.command.sys.exit")
+    def test_edit_file_0(self, mocked_sys_exit, mocked_env_get,
+                         mocked_has_command, mocked_subprocess):
+        BaseCommand.edit_file(self.temp_file.name)
+        self.assertTrue(mocked_sys_exit.called)
+
+    @patch("lava.helper.command.subprocess")
+    @patch("lava.helper.command.has_command", side_effect=[True, False])
+    @patch("lava.helper.command.os.environ.get", return_value=None)
+    def test_edit_file_1(self, mocked_env_get, mocked_has_command,
+                         mocked_subprocess):
+        mocked_subprocess.Popen = MagicMock()
+        BaseCommand.edit_file(self.temp_file.name)
+        expected = [call(["sensible-editor", self.temp_file.name])]
+        self.assertEqual(expected, mocked_subprocess.Popen.call_args_list)
+
+    @patch("lava.helper.command.subprocess")
+    @patch("lava.helper.command.has_command", side_effect=[False, True])
+    @patch("lava.helper.command.os.environ.get", return_value=None)
+    def test_edit_file_2(self, mocked_env_get, mocked_has_command,
+                         mocked_subprocess):
+        mocked_subprocess.Popen = MagicMock()
+        BaseCommand.edit_file(self.temp_file.name)
+        expected = [call(["xdg-open", self.temp_file.name])]
+        self.assertEqual(expected, mocked_subprocess.Popen.call_args_list)
+
+    @patch("lava.helper.command.subprocess")
+    @patch("lava.helper.command.has_command", return_value=False)
+    @patch("lava.helper.command.os.environ.get", return_value="vim")
+    def test_edit_file_3(self, mocked_env_get, mocked_has_command,
+                         mocked_subprocess):
+        mocked_subprocess.Popen = MagicMock()
+        BaseCommand.edit_file(self.temp_file.name)
+        expected = [call(["vim", self.temp_file.name])]
+        self.assertEqual(expected, mocked_subprocess.Popen.call_args_list)
+
+    @patch("lava.helper.command.subprocess")
+    @patch("lava.helper.command.has_command", return_value=False)
+    @patch("lava.helper.command.os.environ.get", return_value="vim")
+    def test_edit_file_4(self, mocked_env_get, mocked_has_command,
+                         mocked_subprocess):
+        mocked_subprocess.Popen = MagicMock()
+        mocked_subprocess.Popen.side_effect = Exception()
+        self.assertRaises(CommandError, BaseCommand.edit_file,
+                          self.temp_file.name)

=== modified file 'lava/helper/tests/test_dispatcher.py'
--- lava/helper/tests/test_dispatcher.py	2013-06-27 12:48:26 +0000
+++ lava/helper/tests/test_dispatcher.py	2013-06-27 12:48:26 +0000
@@ -19,10 +19,12 @@
 """lava.helper.dispatcher tests."""
 
 import os
+import tempfile
+
+from mock import patch
+
 from lava.tool.errors import CommandError
-
 from lava.helper.tests.helper_test import HelperTest
-
 from lava.helper.dispatcher import (
     choose_devices_path,
 )
@@ -30,6 +32,15 @@
 
 class DispatcherTests(HelperTest):
 
+    def setUp(self):
+        super(DispatcherTests, self).setUp()
+        self.devices_dir = os.path.join(tempfile.gettempdir(), "devices")
+        os.makedirs(self.devices_dir)
+
+    def tearDown(self):
+        super(DispatcherTests, self).tearDown()
+        os.removedirs(self.devices_dir)
+
     def test_choose_devices_path_0(self):
         # Tests that when passing more than one path, the first writable one
         # is returned.
@@ -50,3 +61,17 @@
         obtained = choose_devices_path([self.temp_dir])
         self.assertEqual(expected_path, obtained)
         self.assertTrue(os.path.isdir(expected_path))
+
+    def test_choose_devices_path_3(self):
+        # Tests that returns the already existing devices path.
+        obtained = choose_devices_path([tempfile.gettempdir()])
+        self.assertEqual(self.devices_dir, obtained)
+
+    @patch("__builtin__.open")
+    def test_choose_devices_path_4(self, mocked_open):
+        # Tests that when IOError is raised and we pass only one dir
+        # CommandError is raised.
+        mocked_open.side_effect = IOError()
+        self.assertRaises(CommandError, choose_devices_path,
+                          [tempfile.gettempdir()])
+        self.assertTrue(mocked_open.called)

=== modified file 'lava/job/__init__.py'
--- lava/job/__init__.py	2013-06-27 12:48:26 +0000
+++ lava/job/__init__.py	2013-06-27 12:48:26 +0000
@@ -19,7 +19,7 @@
 from copy import deepcopy
 import json
 
-from lava.job.templates import Parameter
+from lava.helper.template import expand_template
 
 
 class Job:
@@ -27,21 +27,7 @@
         self.data = deepcopy(template)
 
     def fill_in(self, config):
-
-        def insert_data(data):
-            if isinstance(data, dict):
-                keys = data.keys()
-            elif isinstance(data, list):
-                keys = range(len(data))
-            else:
-                return
-            for key in keys:
-                entry = data[key]
-                if isinstance(entry, Parameter):
-                    data[key] = config.get(entry)
-                else:
-                    insert_data(entry)
-        insert_data(self.data)
+        expand_template(self.data, config)
 
     def write(self, stream):
         stream.write(json.dumps(self.data, indent=4))

=== modified file 'lava/job/commands.py'
--- lava/job/commands.py	2013-06-27 12:48:26 +0000
+++ lava/job/commands.py	2013-06-27 12:48:26 +0000
@@ -25,12 +25,13 @@
 import xmlrpclib
 
 from lava.helper.command import BaseCommand
+from lava.helper.dispatcher import get_devices
 
-from lava.config import Parameter
 from lava.job import Job
 from lava.job.templates import (
     BOOT_TEST,
 )
+from lava.parameter import Parameter
 from lava.tool.command import CommandGroup
 from lava.tool.errors import CommandError
 from lava_tool.authtoken import AuthenticatingServerProxy, KeyringAuthBackend
@@ -126,7 +127,7 @@
     def invoke(self):
         if os.path.isfile(self.args.FILE):
             if has_command("lava-dispatch"):
-                devices = self.get_devices()
+                devices = get_devices()
                 if devices:
                     if len(devices) > 1:
                         device = self._choose_device(devices)

=== modified file 'lava/job/templates.py'
--- lava/job/templates.py	2013-06-27 12:48:26 +0000
+++ lava/job/templates.py	2013-06-27 12:48:26 +0000
@@ -16,7 +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/>.
 
-from lava.config import Parameter
+from lava.parameter import Parameter
 
 device_type = Parameter("device_type")
 prebuilt_image = Parameter("prebuilt_image", depends=device_type)

=== modified file 'lava/job/tests/test_commands.py'
--- lava/job/tests/test_commands.py	2013-06-27 12:48:26 +0000
+++ lava/job/tests/test_commands.py	2013-06-27 12:48:26 +0000
@@ -25,15 +25,14 @@
 
 from mock import MagicMock, patch
 
-from lava.config import NonInteractiveConfig, Parameter
-
+from lava.config import Config
+from lava.helper.tests.helper_test import HelperTest
 from lava.job.commands import (
     new,
     run,
     submit,
 )
-
-from lava.helper.tests.helper_test import HelperTest
+from lava.parameter import Parameter
 from lava.tool.errors import CommandError
 
 
@@ -46,8 +45,9 @@
         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'})
+        self.config = Config()
+        self.config.put_parameter(self.device_type, 'foo')
+        self.config.put_parameter(self.prebuilt_image, 'bar')
 
     def tmp(self, filename):
         """Returns a path to a non existent file.

=== modified file 'lava/job/tests/test_job.py'
--- lava/job/tests/test_job.py	2013-05-28 22:08:12 +0000
+++ lava/job/tests/test_job.py	2013-06-27 12:48:26 +0000
@@ -21,15 +21,29 @@
 """
 
 import json
+import os
+import tempfile
+
+from StringIO import StringIO
 from unittest import TestCase
-from StringIO import StringIO
 
-from lava.config import NonInteractiveConfig
-from lava.job.templates import *
+from lava.config import Config
 from lava.job import Job
+from lava.job.templates import BOOT_TEST
+from lava.parameter import Parameter
+
 
 class JobTest(TestCase):
 
+    def setUp(self):
+        self.config_file = tempfile.NamedTemporaryFile(delete=False)
+        self.config = Config()
+        self.config._config_file = self.config_file.name
+
+    def tearDown(self):
+        if os.path.isfile(self.config_file.name):
+            os.unlink(self.config_file.name)
+
     def test_from_template(self):
         template = {}
         job = Job(template)
@@ -37,21 +51,20 @@
         self.assertIsNot(job.data, template)
 
     def test_fill_in_data(self):
+        image = "/path/to/panda.img"
+        param1 = Parameter("device_type")
+        param2 = Parameter("prebuilt_image", depends=param1)
+        self.config.put_parameter(param1, "panda")
+        self.config.put_parameter(param2, image)
+
         job = Job(BOOT_TEST)
-        image = "/path/to/panda.img"
-        config = NonInteractiveConfig(
-            {
-                "device_type": "panda",
-                "prebuilt_image": image,
-            }
-        )
-        job.fill_in(config)
+        job.fill_in(self.config)
 
         self.assertEqual(job.data['device_type'], "panda")
         self.assertEqual(job.data['actions'][0]["parameters"]["image"], image)
 
     def test_write(self):
-        orig_data = { "foo": "bar" }
+        orig_data = {"foo": "bar"}
         job = Job(orig_data)
         output = StringIO()
         job.write(output)
@@ -60,7 +73,7 @@
         self.assertEqual(data, orig_data)
 
     def test_writes_nicely_formatted_json(self):
-        orig_data = { "foo": "bar" }
+        orig_data = {"foo": "bar"}
         job = Job(orig_data)
         output = StringIO()
         job.write(output)

=== added file 'lava/parameter.py'
--- lava/parameter.py	1970-01-01 00:00:00 +0000
+++ lava/parameter.py	2013-06-27 12:48:26 +0000
@@ -0,0 +1,75 @@
+# Copyright (C) 2013 Linaro Limited
+#
+# Author: Antonio Terceiro <[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/>.
+
+"""
+Parameter class and its accessory methods/functions.
+"""
+
+import sys
+
+
+class Parameter(object):
+    """A parameter with an optional dependency."""
+    def __init__(self, id, value=None, depends=None):
+        """Creates a new parameter.
+
+        :param id: The name of this parameter.
+        :param value: The value of this parameter. Defaults to None.
+        :param depends: If this Parameter depends on another one. Defaults
+                        to None.
+        :type Parameter
+        """
+        self.id = id
+        self.value = value
+        self.depends = depends
+        self.asked = False
+
+    def prompt(self, old_value=None):
+        """Gets the parameter value from the user.
+
+        To get user input, the builtin `raw_input` function will be used. Input
+        will also be stripped of possible whitespace chars. If Enter or any
+        sort of whitespace chars in typed, the old Parameter value will be
+        returned.
+
+        :param old_value: The old parameter value.
+        :return The input as typed by the user, or the old value.
+        """
+        if old_value is not None:
+            prompt = "{0} [{1}]: ".format(self.id, old_value)
+        else:
+            prompt = "{0}: ".format(self.id)
+
+        user_input = None
+        try:
+            user_input = raw_input(prompt).strip()
+        except EOFError:
+            pass
+        except KeyboardInterrupt:
+            sys.exit(-1)
+
+        if user_input is not None:
+            if len(user_input) == 0 and old_value:
+                # Keep the old value when user press enter or another
+                # whitespace char.
+                self.value = old_value
+            else:
+                self.value = user_input
+
+        self.asked = True
+        return self.value

=== added directory 'lava/tests'
=== added file 'lava/tests/__init__.py'
=== added file 'lava/tests/test_config.py'
--- lava/tests/test_config.py	1970-01-01 00:00:00 +0000
+++ lava/tests/test_config.py	2013-06-27 12:48:26 +0000
@@ -0,0 +1,278 @@
+# 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.config unit tests.
+"""
+
+import os
+import sys
+import tempfile
+
+from StringIO import StringIO
+from mock import MagicMock, patch, call
+
+from lava.config import (
+    Config,
+    InteractiveConfig,
+    ConfigParser,
+)
+from lava.helper.tests.helper_test import HelperTest
+from lava.parameter import Parameter
+from lava.tool.errors import CommandError
+
+
+class MockedConfig(Config):
+    """A subclass of the original Config class.
+
+    Used to test the Config class, but to not have the same constructor in
+    order to use temporary files for the configuration.
+    """
+    def __init__(self, config_file):
+        self._cache = {}
+        self._config_file = config_file
+        self._config_backend = ConfigParser()
+        self._config_backend.read([self._config_file])
+
+
+class MockedInteractiveConfig(InteractiveConfig):
+    def __init__(self, config_file, force_interactive=False):
+        self._cache = {}
+        self._config_file = config_file
+        self._config_backend = ConfigParser()
+        self._config_backend.read([self._config_file])
+        self._force_interactive = force_interactive
+
+
+class ConfigTestCase(HelperTest):
+    """General test case class for the different Config classes."""
+    def setUp(self):
+        super(ConfigTestCase, self).setUp()
+        self.config_file = tempfile.NamedTemporaryFile(delete=False)
+
+        self.param1 = Parameter("foo")
+        self.param2 = Parameter("bar", depends=self.param1)
+
+    def tearDown(self):
+        super(ConfigTestCase, self).tearDown()
+        if os.path.isfile(self.config_file.name):
+            os.unlink(self.config_file.name)
+
+
+class ConfigTest(ConfigTestCase):
+
+    def setUp(self):
+        super(ConfigTest, self).setUp()
+        self.config = MockedConfig(self.config_file.name)
+
+    def test_assert_temp_config_file(self):
+        # Dummy test to make sure we are overriding correctly the Config class.
+        self.assertEqual(self.config._config_file, self.config_file.name)
+
+    def test_config_put_in_cache_0(self):
+        self.config._put_in_cache("key", "value", "section")
+        self.assertEqual(self.config._cache["section"]["key"], "value")
+
+    def test_config_get_from_cache_0(self):
+        self.config._put_in_cache("key", "value", "section")
+        obtained = self.config._get_from_cache(Parameter("key"), "section")
+        self.assertEqual("value", obtained)
+
+    def test_config_get_from_cache_1(self):
+        self.config._put_in_cache("key", "value", "DEFAULT")
+        obtained = self.config._get_from_cache(Parameter("key"), "DEFAULT")
+        self.assertEqual("value", obtained)
+
+    def test_config_put_0(self):
+        # Puts a value in the DEFAULT section.
+        self.config._put_in_cache = MagicMock()
+        self.config.put("foo", "foo")
+        expected = "foo"
+        obtained = self.config._config_backend.get("DEFAULT", "foo")
+        self.assertEqual(expected, obtained)
+
+    def test_config_put_1(self):
+        # Puts a value in a new section.
+        self.config._put_in_cache = MagicMock()
+        self.config.put("foo", "foo", "bar")
+        expected = "foo"
+        obtained = self.config._config_backend.get("bar", "foo")
+        self.assertEqual(expected, obtained)
+
+    def test_config_put_parameter_0(self):
+        self.config._calculate_config_section = MagicMock(return_value="")
+        self.assertRaises(CommandError, self.config.put_parameter, self.param1)
+
+    @patch("lava.config.Config.put")
+    def test_config_put_parameter_1(self, mocked_config_put):
+        self.config._calculate_config_section = MagicMock(
+            return_value="DEFAULT")
+
+        self.param1.value = "bar"
+        self.config.put_parameter(self.param1)
+
+        self.assertEqual(mocked_config_put.mock_calls,
+                         [call("foo", "bar", "DEFAULT")])
+
+    def test_config_get_0(self):
+        # Tests that with a non existing parameter, it returns None.
+        param = Parameter("baz")
+        self.config._get_from_cache = MagicMock(return_value=None)
+        self.config._calculate_config_section = MagicMock(
+            return_value="DEFAULT")
+
+        expected = None
+        obtained = self.config.get(param)
+        self.assertEqual(expected, obtained)
+
+    def test_config_get_1(self):
+        self.config.put_parameter(self.param1, "foo")
+        self.config._get_from_cache = MagicMock(return_value=None)
+        self.config._calculate_config_section = MagicMock(
+            return_value="DEFAULT")
+
+        expected = "foo"
+        obtained = self.config.get(self.param1)
+        self.assertEqual(expected, obtained)
+
+    def test_calculate_config_section_0(self):
+        expected = "DEFAULT"
+        obtained = self.config._calculate_config_section(self.param1)
+        self.assertEqual(expected, obtained)
+
+    def test_calculate_config_section_1(self):
+        self.config.put_parameter(self.param1, "foo")
+        expected = "foo=foo"
+        obtained = self.config._calculate_config_section(self.param2)
+        self.assertEqual(expected, obtained)
+
+    def test_config_save(self):
+        self.config.put_parameter(self.param1, "foo")
+        self.config.save()
+
+        expected = "[DEFAULT]\nfoo = foo\n\n"
+        obtained = ""
+        with open(self.config_file.name) as tmp_file:
+            obtained = tmp_file.read()
+        self.assertEqual(expected, obtained)
+
+    @patch("lava.config.AT_EXIT_CALLS", spec=set)
+    def test_config_atexit_call_list(self, mocked_calls):
+        # Tests that the save() method is added to the set of atexit calls.
+        config = Config()
+        config._config_file = self.config_file.name
+        config.put_parameter(self.param1, "foo")
+
+        expected = [call.add(config.save)]
+
+        self.assertEqual(expected, mocked_calls.mock_calls)
+
+
+class InteractiveConfigTest(ConfigTestCase):
+
+    def setUp(self):
+        super(InteractiveConfigTest, self).setUp()
+        self.config = MockedInteractiveConfig(
+            config_file=self.config_file.name)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value=None))
+    def test_non_interactive_config_0(self):
+        # Mocked config default is not to be interactive.
+        # Try to get a value that does not exists, users just press enter when
+        # asked for a value. Value will be empty.
+        sys.stdin = StringIO("\n")
+        value = self.config.get(Parameter("foo"))
+        self.assertEqual("", value)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value="value"))
+    def test_non_interactive_config_1(self):
+        # Parent class config returns a value, but we are not interactive.
+        value = self.config.get(Parameter("foo"))
+        self.assertEqual("value", value)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value=None))
+    def test_non_interactive_config_2(self):
+        expected = "bar"
+        sys.stdin = StringIO(expected)
+        value = self.config.get(Parameter("foo"))
+        self.assertEqual(expected, value)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value="value"))
+    def test_interactive_config_0(self):
+        # We force to be interactive, meaning that even if a value is found,
+        # it will be asked anyway.
+        self.config._force_interactive = True
+        expected = "a_new_value"
+        sys.stdin = StringIO(expected)
+        value = self.config.get(Parameter("foo"))
+        self.assertEqual(expected, value)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value="value"))
+    def test_interactive_config_1(self):
+        # Force to be interactive, but when asked for the new value press
+        # Enter. The old value should be returned.
+        self.config._force_interactive = True
+        sys.stdin = StringIO("\n")
+        value = self.config.get(Parameter("foo"))
+        self.assertEqual("value", value)
+
+    def test_calculate_config_section_0(self):
+        self.config._force_interactive = True
+        obtained = self.config._calculate_config_section(self.param1)
+        expected = "DEFAULT"
+        self.assertEqual(expected, obtained)
+
+    def test_calculate_config_section_1(self):
+        self.param2.depends.asked = True
+        self.config._force_interactive = True
+        self.config.put(self.param1.id, "foo")
+        obtained = self.config._calculate_config_section(self.param2)
+        expected = "foo=foo"
+        self.assertEqual(expected, obtained)
+
+    def test_calculate_config_section_2(self):
+        self.config._force_interactive = True
+        self.config._config_backend.get = MagicMock(return_value=None)
+        sys.stdin = StringIO("baz")
+        expected = "foo=baz"
+        obtained = self.config._calculate_config_section(self.param2)
+        self.assertEqual(expected, obtained)
+
+    def test_calculate_config_section_3(self):
+        # Tests that when a parameter has its value in the cache and also on
+        # file, we honor the cached version.
+        self.param2.depends.asked = True
+        self.config._force_interactive = True
+        self.config._get_from_cache = MagicMock(return_value="bar")
+        self.config._config_backend.get = MagicMock(return_value="baz")
+        expected = "foo=bar"
+        obtained = self.config._calculate_config_section(self.param2)
+        self.assertEqual(expected, obtained)
+
+    @patch("lava.config.Config.get", new=MagicMock(return_value=None))
+    @patch("lava.parameter.sys.exit")
+    @patch("lava.parameter.raw_input", create=True)
+    def test_interactive_config_exit(self, mocked_raw, mocked_sys_exit):
+        self.config._calculate_config_section = MagicMock(
+            return_value="DEFAULT")
+
+        mocked_raw.side_effect = KeyboardInterrupt()
+
+        self.config._force_interactive = True
+        self.config.get(self.param1)
+        self.assertTrue(mocked_sys_exit.called)

=== added file 'lava/tests/test_parameter.py'
--- lava/tests/test_parameter.py	1970-01-01 00:00:00 +0000
+++ lava/tests/test_parameter.py	2013-06-27 12:48:26 +0000
@@ -0,0 +1,51 @@
+# 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.parameter unit tests.
+"""
+
+import sys
+
+from StringIO import StringIO
+from mock import patch
+
+from lava.helper.tests.helper_test import HelperTest
+from lava.parameter import Parameter
+
+
+class ParameterTest(HelperTest):
+
+    def setUp(self):
+        super(ParameterTest, self).setUp()
+        self.parameter1 = Parameter("foo", value="baz")
+
+    def test_prompt_0(self):
+        # Tests that when we have a value in the parameters and the user press
+        # Enter, we get the old value back.
+        sys.stdin = StringIO("\n")
+        obtained = self.parameter1.prompt()
+        self.assertEqual(self.parameter1.value, obtained)
+
+    @patch("lava.parameter.raw_input", create=True)
+    def test_prompt_1(self, mocked_raw_input):
+        # Tests that with a value stored in the parameter, if and EOFError is
+        # raised when getting user input, we get back the old value.
+        mocked_raw_input.side_effect = EOFError()
+        obtained = self.parameter1.prompt()
+        self.assertEqual(self.parameter1.value, obtained)

=== modified file 'lava_tool/tests/__init__.py'
--- lava_tool/tests/__init__.py	2013-06-27 12:48:26 +0000
+++ lava_tool/tests/__init__.py	2013-06-27 12:48:26 +0000
@@ -44,6 +44,8 @@
         'lava.job.tests.test_commands',
         'lava.device.tests.test_device',
         'lava.device.tests.test_commands',
+        'lava.tests.test_config',
+        'lava.tests.test_parameter',
         'lava.helper.tests.test_command',
         'lava.helper.tests.test_dispatcher',
     ]