Merge lp:~zyga/lava-core/workspace into lp:lava-core

[Zygmunt Krynicki]

This branch adds the workspace concept and a few tests

=== modified file 'lava/core/environment.py'
--- lava/core/environment.py	2012-05-07 09:11:28 +0000
+++ lava/core/environment.py	2012-05-28 06:43:19 +0000
@@ -48,7 +48,9 @@
         "type": "object",
         "properties": {
             "name": {
-                "type": "string"
+                "type": "string",
+                "optional": True,
+                "default": None
             },
         }
     }
@@ -57,4 +59,4 @@
     def name(self):
         """
         Human readable name of the environment
-        """
\ No newline at end of file
+        """

=== added file 'lava/core/tests/test_workspace.py'
--- lava/core/tests/test_workspace.py	1970-01-01 00:00:00 +0000
+++ lava/core/tests/test_workspace.py	2012-05-28 06:43:19 +0000
@@ -0,0 +1,198 @@
+# Copyright (C) 2011-2012 Linaro Limited
+#
+# Author: Zygmunt Krynicki <[e-mail]>
+#
+# This file is part of lava-core
+#
+# lava-core 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-core 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-core.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+lava.core.tests.test_workspace
+==============================
+
+Tests for lava.core.workspace
+"""
+
+import os
+
+from unittest2 import TestCase
+from mockfs import MockedFileSystem
+
+from lava.core.workspace import Workspace
+from lava.core.environment import Environment
+
+
+class WorkspaceTests(TestCase):
+
+    _location = "location"
+    _location_nested = "location/nested/somewhere"
+    _name = "name"
+
+    def setUp(self):
+        super(WorkspaceTests, self).setUp()
+        self.fs = MockedFileSystem()
+
+    def create_workspace(self, location=".", environment_text="{ }"):
+        """
+        Create a workspace with at the specified location and add the
+        environment json with the specified text to it.
+        """
+        lava_dir = os.path.join(location, ".lava")
+        if not os.path.exists(lava_dir):
+            os.makedirs(lava_dir)
+        env_path = os.path.join(lava_dir, "environment.json")
+        with file(env_path, "wt") as stream:
+            stream.write(environment_text)
+
+    def test__init__with_workspace(self):
+        """
+        Workspace() works when .lava directory is found
+        """
+        with self.fs.record():
+            self.create_workspace(self._location)
+        with self.fs.replay():
+            Workspace(self._location)
+            self.assertTrue(True)
+
+    def test__init__without_workspace(self):
+        """
+        Workspace() raises EnvironmentError when .lava is not found
+        """
+        with self.assertRaises(EnvironmentError):
+            Workspace(self._location)
+
+    def test_location(self):
+        """
+        Workspace().location returns the location of the workspace
+        """
+        with self.fs.record():
+            self.create_workspace(self._location)
+        with self.fs.replay():
+            workspace = Workspace(self._location)
+            self.assertEqual(workspace.location, self._location)
+
+    def test_environment_returns_Environment(self):
+        """
+        Workspace().environment returns an Environment object
+        """
+        with self.fs.record():
+            self.create_workspace(self._location)
+        with self.fs.replay():
+            workspace = Workspace(self._location)
+            self.assertIsInstance(workspace.environment, Environment)
+
+    def test_environment_is_initially_empty(self):
+        """
+        Workspace().environment is initially empty ({})
+
+        Despite .lava/environment.json having content, the environment is empty
+        before we call .load_environment()
+        """
+        with self.fs.record():
+            self.create_workspace(
+                self._location, environment_text='{"I_am_not": "empty" }')
+        with self.fs.replay():
+            workspace = Workspace(self._location)
+            self.assertEqual(workspace.environment.value, {})
+
+    def test_load_environment_loads_json(self):
+        """
+        Workspace().load_environment() loads stuff from disk
+        """
+        with self.fs.record():
+            self.create_workspace(
+                self._location, environment_text='{"name": "Unit test" }')
+        with self.fs.replay():
+            workspace = Workspace(self._location)
+            workspace.load_environment()
+            self.assertEqual(workspace.environment.value,
+                             {"name": "Unit test"})
+
+    def test_save_environment_saves_json(self):
+        """
+        Workspace().save_environment() saves stuff to disk
+
+        (it's actually only doing that when modified but I'm not going to test
+        for that here)
+        """
+        with self.fs.record():
+            # NOTE: it's sad but MockedFileSystem cannot open a file twice (it
+            # raises an exception when that is attempted), it's a tradeoff
+            # between ease-of-implementation and features. Once I finish fakefs
+            # we can just call self.create_workspace() here
+            os.makedirs(os.path.join(self._location, ".lava"))
+            workspace = Workspace(self._location)
+            workspace.environment.name = self._name
+            workspace.save_environment()
+        with self.fs.replay():
+            # NOTE: for clarity, it's worth pointing out that replay() puts the
+            # filesystem in read-only mode while record() does not allow one to
+            # read what was written (this was a poor choice from
+            # retrospective). Without those limits the test would have been
+            # less complicated.
+            workspace = Workspace(self._location)
+            workspace.load_environment()
+            self.assertEqual(workspace.environment.name, self._name)
+
+    def test_create(self):
+        """
+        Workspace.create() creates and returns a workspace
+        """
+        with self.fs.record():
+            workspace = Workspace.create(self._location)
+        with self.fs.replay():
+            # Create makes both the location
+            self.assertTrue(os.path.exists(workspace.location))
+            # and the .lava directory inside
+            self.assertTrue(os.path.exists(workspace._lava_dir))
+            # ... and even a stub environment.json file
+            self.assertTrue(os.path.exists(workspace._environment_pathname))
+
+    def test_create_output_works(self):
+        """
+        Workspace.create() creates something that can be used later
+        """
+        with self.fs.record():
+            Workspace.create(self._location)
+        with self.fs.replay():
+            workspace = Workspace(self._location)
+            workspace.load_environment()
+            # how I wish TestCase had provided assertNotRaises()
+            self.assertEqual(workspace.environment.validate(), None)
+
+    def test_find_without_workspace(self):
+        """
+        Workspace.find() raises LookupError if there is no workspace anywhere
+        _above_
+        """
+        with self.fs.replay():
+            with self.assertRaises(LookupError):
+                Workspace.find()
+        with self.fs.record():
+            os.makedirs('foo/.lava/')
+        with self.fs.replay():
+            with self.assertRaises(LookupError):
+                Workspace.find('foo')
+
+    def test_find_with_workspace(self):
+        """
+        Workspace.find() correctly finds workspaces in the current directory
+        and above
+        """
+        with self.fs.record():
+            os.mkdir('/home/user/.lava')
+            os.mkdir('/home/user/.lava/something/')
+        with self.fs.replay():
+            workspace = Workspace.find('/home/user/.lava/something/')
+            self.assertEqual(workspace.location, '/home/user')
+            self.assertEqual(workspace._lava_dir, '/home/user/.lava')

=== added file 'lava/core/workspace.py'
--- lava/core/workspace.py	1970-01-01 00:00:00 +0000
+++ lava/core/workspace.py	2012-05-28 06:43:19 +0000
@@ -0,0 +1,138 @@
+# Copyright (C) 2011-2012 Linaro Limited
+#
+# Author: Zygmunt Krynicki <[e-mail]>
+#
+# This file is part of lava-core
+#
+# lava-core 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-core 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-core.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import absolute_import
+
+"""
+lava.core.workspace
+===================
+"""
+
+import os
+
+from json_document.shortcuts import persistence
+
+from lava.core.environment import Environment
+from lava.core.logging import LoggingMixIn
+
+
+class Workspace(LoggingMixIn):
+    """
+    Container for LAVA configuration and other runtime data. Also know as the
+    .lava directory
+    """
+
+    def __init__(self, location):
+        """
+        Initialize a workspace with an existing on-disk location.  location
+        must point to a directory that has the '.lava' sub-directory.
+        """
+        # self._location = os.path.abspath(location)
+        self._location = location
+        if not os.path.exists(self._lava_dir):
+            raise EnvironmentError("Workspace must have a .lava directory")
+        self._environment = Environment({})
+        self._env_persistence = persistence(
+            self._environment, self._environment_pathname)
+
+    @property
+    def location(self):
+        """
+        location of this workspace
+
+        The location does not include the .lava directory
+        The location is an absolute pathname, regardless of
+        how it was passed to the constructor.
+        """
+        return self._location
+
+    @property
+    def environment(self):
+        """
+        :class:`lava.core.environment.Environment` object of this workspace
+
+        .. note::
+            This object is initially empty (empty environment), to use an
+            actual environment you must call load_environment() and deal with
+            any errors.
+        """
+        return self._environment
+
+    def load_environment(self):
+        """
+        Load and return the workspace environment
+        """
+        # TODO: fs lock
+        self._env_persistence.load()
+        return self._environment
+
+    def save_environment(self):
+        """
+        Save environment back to the filesystem, if needed
+        """
+        # TODO: fs lock
+        self._env_persistence.save()
+
+    @classmethod
+    def create(cls, location='.'):
+        """
+        Create a new workspace in the specified location.
+
+        Parent workspace lookup is _not_ performed. This is a filesystem
+        synchronization/race point, if the caller looses an OSError is raised.
+        """
+        os.makedirs(os.path.join(location, '.lava'))
+        self = cls(location)
+        with open(self._environment_pathname, 'wt') as stream:
+            stream.write("{ }")
+        return self
+
+    @classmethod
+    def find(cls, start_dir='.'):
+        """
+        Find a Workspace, starting the search at start_dir and working up the
+        directory tree
+        """
+        location = start_dir
+        last_location = None
+        # Keep on "going" as long as we're moving
+        while last_location is None or (os.path.abspath(location) !=
+                                        os.path.abspath(last_location)):
+            candidate = os.path.join(location, '.lava')
+            candidate = os.path.normpath(candidate)
+            # XXX: replace with os.path.isdir once mockfs supports that
+            if os.path.exists(candidate):
+                return cls(location)
+            last_location = location
+            location = os.path.join(location, "..")
+            location = os.path.normpath(location)
+        raise LookupError(".lava directory not found")
+
+    @property
+    def _lava_dir(self):
+        """
+        pathname of the .lava directory
+        """
+        return os.path.join(self._location, '.lava')
+
+    @property
+    def _environment_pathname(self):
+        """
+        pathname of the 'environment.json' file
+        """
+        return os.path.join(self._lava_dir, 'environment.json')