Remove more ZI remains

* one command per context;
* exact dependency comparing.

9 files changed, 319 insertions, 403 deletions

diff --git a/sugar_network/model/__init__.py b/sugar_network/model/__init__.py
index f7be261..5b7a245 100644
--- a/sugar_network/model/__init__.py
+++ b/sugar_network/model/__init__.py
@@ -83,15 +83,15 @@ class Release(object):
             __, release = load_bundle(
                     blobs.post(release, this.request.content_type),
                     context=this.request.guid)
-        return release['spec']['*-*']['bundle'], release
+        return release['bundles']['*-*']['blob'], release
 
     def teardown(self, release):
         if this.resource.exists and \
                 'activity' not in this.resource['type'] and \
                 'book' not in this.resource['type']:
             return
-        for spec in release['spec'].values():
-            blobs.delete(spec['bundle'])
+        for bundle in release['bundles'].values():
+            blobs.delete(bundle['blob'])
 
     def encode(self, value):
         return []
@@ -147,9 +147,11 @@ def load_bundle(blob, context=None, initial=False, extra_deps=None):
             release['license'] = this.request['license']
             if isinstance(release['license'], basestring):
                 release['license'] = [release['license']]
-        release['spec'] = {'*-*': {
-            'bundle': blob.digest,
-            }}
+        release['bundles'] = {
+                '*-*': {
+                    'bundle': blob.digest,
+                    },
+                }
     else:
         context_type = 'activity'
         unpack_size = 0
@@ -177,12 +179,14 @@ def load_bundle(blob, context=None, initial=False, extra_deps=None):
         release['stability'] = spec['stability']
         if spec['license'] is not EMPTY_LICENSE:
             release['license'] = spec['license']
-        release['commands'] = spec.commands
+        release['command'] = spec.command
         release['requires'] = spec.requires
-        release['spec'] = {'*-*': {
-            'bundle': blob.digest,
-            }}
-        release['unpack_size'] = unpack_size
+        release['bundles'] = {
+                '*-*': {
+                    'blob': blob.digest,
+                    'unpack_size': unpack_size,
+                    },
+                }
         blob['content-type'] = 'application/vnd.olpc-sugar'
 
     enforce(context, http.BadRequest, 'Context is not specified')
diff --git a/sugar_network/node/model.py b/sugar_network/node/model.py
index 7276b75..9ead01c 100644
--- a/sugar_network/node/model.py
+++ b/sugar_network/node/model.py
@@ -176,7 +176,7 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
     top_stability = stability or ['stable']
     if isinstance(top_stability, basestring):
         top_stability = [top_stability]
-    top_cond = None
+    top_cond = []
     top_requires = {}
     if isinstance(requires, basestring):
         top_requires.update(spec.parse_requires(requires))
@@ -196,15 +196,6 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
     _logger.debug('Solve %r lsb_id=%r lsb_release=%r stability=%r requires=%r',
             top_context.guid, lsb_id, lsb_release, top_stability, top_requires)
 
-    def ensure_version(version, cond):
-        if not cond:
-            return True
-        for not_before, before in cond['restrictions']:
-            if before is not None and version >= before or \
-                    not_before is not None and version < not_before:
-                return False
-        return True
-
     def rate_release(digest, release):
         return [_STABILITY_RATES.get(release['stability']) or 0,
                 release['version'],
@@ -217,7 +208,7 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
         for dep, cond in deps.items():
             dep_clause = [-v_usage]
             for v_release in add_context(dep):
-                if ensure_version(varset[v_release][0], cond):
+                if spec.ensure(varset[v_release][1]['version'], cond):
                     dep_clause.append(v_release)
             clauses.append(dep_clause)
 
@@ -242,7 +233,10 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
                     pkg_lst = alias.get('binary', []) + alias.get('devel', [])
             if pkg_lst:
                 clause.append(len(varset))
-                varset.append((pkg_ver, 'packages', {context.guid: pkg_lst}))
+                varset.append((
+                    context.guid,
+                    {'version': pkg_ver, 'packages': pkg_lst},
+                    ))
         else:
             candidates = []
             for digest, release in releases.items():
@@ -251,18 +245,17 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
                 release = release['value']
                 if release['stability'] not in top_stability or \
                         context.guid == top_context.guid and \
-                            not ensure_version(release['version'], top_cond):
+                            not spec.ensure(release['version'], top_cond):
                     continue
                 bisect.insort(candidates, rate_release(digest, release))
             for release in reversed(candidates):
                 digest = release[-1]
                 release = releases[digest]['value']
+                release_info = {'version': release['version'], 'blob': digest}
+                if context.guid == top_context.guid:
+                    release_info['command'] = release['command']
                 v_release = len(varset)
-                varset.append((
-                    release['version'],
-                    'files',
-                    {context.guid: digest},
-                    ))
+                varset.append((context.guid, release_info))
                 clause.append(v_release)
                 add_deps(context, v_release, release.get('requires') or {})
 
@@ -283,13 +276,7 @@ def solve(volume, top_context, lsb_id=None, lsb_release=None,
     if not top_context.guid in result:
         _logger.debug('No top versions for %r', top_context.guid)
         return None
-
-    solution = {'files': {}, 'packages': {}}
-    for v in result.values():
-        __, key, items = varset[v]
-        solution[key].update(items)
-    top_release = top_context['releases'][solution['files'][top_context.guid]]
-    solution['commands'] = top_release['value']['commands']
+    solution = dict([varset[i] for i in result.values()])
 
     _logger.debug('Solution for %r: %r', top_context.guid, solution)
 
diff --git a/sugar_network/node/routes.py b/sugar_network/node/routes.py
index 66b7823..6d5d200 100644
--- a/sugar_network/node/routes.py
+++ b/sugar_network/node/routes.py
@@ -27,8 +27,7 @@ from sugar_network.node import stats_user, model
 # pylint: disable-msg=W0611
 from sugar_network.toolkit.router import route, preroute, postroute, ACL
 from sugar_network.toolkit.router import Unauthorized, Request, fallbackroute
-from sugar_network.toolkit.spec import parse_requires, ensure_requires
-from sugar_network.toolkit.spec import parse_version
+from sugar_network.toolkit.spec import parse_requires, parse_version
 from sugar_network.toolkit.bundle import Bundle
 from sugar_network.toolkit.coroutine import this
 from sugar_network.toolkit import pylru, http, coroutine, exception, enforce
@@ -157,7 +156,7 @@ class NodeRoutes(db.Routes, FrontRoutes):
             arguments={'requires': list})
     def get_clone(self, request, response):
         solution = self.solve(request)
-        return blobs.get(solution['files'][request.guid])
+        return blobs.get(solution[request.guid]['blob'])
 
     @route('GET', ['user', None], cmd='stats-info',
             mime_type='application/json', acl=ACL.AUTH)
diff --git a/sugar_network/toolkit/spec.py b/sugar_network/toolkit/spec.py
index 78c6007..a8489ce 100644
--- a/sugar_network/toolkit/spec.py
+++ b/sugar_network/toolkit/spec.py
@@ -15,7 +15,6 @@
 
 import re
 import os
-import sys
 import logging
 from os.path import join, exists, dirname
 from ConfigParser import ConfigParser
@@ -45,7 +44,7 @@ _STABILITIES = ('insecure', 'buggy', 'developer', 'testing', 'stable')
 _POLICY_URL = 'http://wiki.sugarlabs.org/go/Sugar_Network/Policy'
 _LIST_SEPARATOR = ','
 
-_RESTRICTION_RE = re.compile('(<|<=|=|>|>=)\\s*([0-9.]+)')
+_RESTRICTION_RE = re.compile('(<|<=|=|==|>|>=)\\s*([0-9.]+)')
 
 _VERSION_RE = re.compile('-([a-z]*)')
 _VERSION_MOD_TO_VALUE = {
@@ -146,89 +145,47 @@ def format_version(version):
     return ''.join(version)
 
 
-def format_next_version(version, deep=True):
-    """Convert incremented version to string representation.
-
-    Before convertation, the last version's rank will be incremented.
-    If string value is passed, it will be parsed to procuduce
-    canonicalized string representation.
-
-    """
-    if version is None:
-        return None
-    if isinstance(version, basestring):
-        version = parse_version(version)
-    if deep:
-        version[-2] += [1]
-    else:
-        version[-2][-1] += 1
-    return format_version(version)
-
-
 def parse_requires(requires):
     result = {}
 
     for dep_str in _parse_list(requires):
-        dep = _Dependency()
-
-        if dep_str.startswith('[') and dep_str.endswith(']'):
-            dep_str = dep_str[1:-1]
-            dep['importance'] = 'recommended'
-
         parts = _RESTRICTION_RE.split(dep_str)
-        enforce(parts[0], 'Can parse dependency from "%s" string', dep_str)
-
+        enforce(parts[0], 'Cannot parse %r dependency', dep_str)
         dep_name = parts.pop(0).strip()
-        if dep_name in result:
-            result[dep_name].update(dep)
-            dep = result[dep_name]
-        else:
-            result[dep_name] = dep
+        dep = result.setdefault(dep_name, [])
 
-        not_before = None
-        before = None
         while len(parts) >= 3:
-            if parts[0] == '<':
-                before = format_version(parts[1])
-            elif parts[0] == '<=':
-                before = format_next_version(parts[1], False)
-            elif parts[0] == '>':
-                not_before = format_next_version(parts[1], False)
-            elif parts[0] == '>=':
-                not_before = format_version(parts[1])
-            elif parts[0] == '=':
-                not_before = format_version(parts[1])
-                before = format_next_version(parts[1], False)
+            rel = parts[0]
+            if rel in ('=', '=='):
+                rel = [0]
+            elif rel == '<':
+                rel = [-1]
+            elif rel == '>':
+                rel = [1]
+            elif rel == '<=':
+                rel = [-1, 0]
+            elif rel == '>=':
+                rel = [1, 0]
+            dep.append((rel, parse_version(parts[1])))
             del parts[:3]
 
         enforce(not parts or not parts[0].strip(),
-                'Cannot parse "%s", it should be in format '
-                '"<dependency> (>=|<|=) <version>"', dep_str)
-
-        if before or not_before:
-            dep.setdefault('restrictions', [])
-            dep['restrictions'].append((not_before, before))
+                'Cannot parse %r dependency', dep_str)
 
     return result
 
 
-def ensure_requires(to_consider, to_apply):
-
-    def intersect(x, y):
-        l = max([parse_version(i) for i, __ in (x + y)])
-        r = min([[[sys.maxint]] if i is None else parse_version(i)
-                for __, i in (x + y)])
-        return l is None or r is None or l < r
-
-    for name, cond in to_apply.items():
-        dep = to_consider.get(name)
-        if dep is None:
-            return False
-        if 'restrictions' not in dep or 'restrictions' not in cond:
-            continue
-        if not intersect(dep['restrictions'], cond['restrictions']):
-            return False
-
+def ensure(version, cond):
+    if cond:
+        for op, cond_version in cond:
+            if op == [0]:
+                # Make `version` the same length as `cond_version`
+                if len(version) > len(cond_version):
+                    version = version[:len(cond_version) - 1] + [0]
+                if len(version[0]) > len(cond_version[0]):
+                    version = [version[0][:len(cond_version[0])], 0]
+            if cmp(version, cond_version) not in op:
+                return False
     return True
 
 
@@ -236,7 +193,7 @@ class Spec(object):
 
     def __init__(self, spec=None, root=None):
         self.path = None
-        self.commands = {}
+        self.command = None
         self.bindings = set()
         self.requires = {}
         self.build_requires = []
@@ -391,14 +348,12 @@ class Spec(object):
             i.name = '-'.join(i.section.split(':')[1:])
 
     def _new_command(self, section, requires, name):
+        enforce(self.command is None, 'Only one command is allowed')
         cmdline = self._get(section, 'exec')
         enforce(cmdline,
                 'Option "exec" should exist for [%s] section', section)
-        command = self.commands[name] = _Command(name, cmdline)
-        if ':' in section:
-            command.requires.update(requires)
-        else:
-            self.requires.update(requires)
+        self.command = cmdline
+        self.requires.update(requires)
 
     def _new_activity(self, section, requires):
         enforce(':' not in section, '[Activity] should be singular')
@@ -476,34 +431,6 @@ class _Library(_Section):
     pass
 
 
-class _Command(dict):
-
-    def __init__(self, name, cmdline):
-        dict.__init__(self)
-        self['exec'] = cmdline
-        self.name = name
-        self.requires = {}
-
-
-class _Dependency(dict):
-
-    def versions_range(self):
-        for not_before, before in self.get('restrictions') or []:
-            if not_before is None:
-                continue
-            i = parse_version(not_before)[0]
-            yield format_version([i, 0])
-            if before is None:
-                continue
-            end = parse_version(before)[0]
-            i = i[:min(len(i), len(end))]
-            while True:
-                i[-1] += 1
-                if i >= end:
-                    break
-                yield format_version([i, 0])
-
-
 def _parse_bindings(text):
     result = set()
 
diff --git a/tests/units/model/context.py b/tests/units/model/context.py
index 8fd5b56..0990f15 100755
--- a/tests/units/model/context.py
+++ b/tests/units/model/context.py
@@ -79,10 +79,9 @@ class ContextTest(tests.Test):
                     'announce': next(volume['post'].find(query='title:1')[0]).guid,
                     'version': [[1], 0],
                     'requires': {},
-                    'commands': {'activity': {'exec': 'true'}},
-                    'spec': {'*-*': {'bundle': str(hash(bundle1))}},
+                    'command': 'true',
+                    'bundles': {'*-*': {'blob': str(hash(bundle1)), 'unpack_size': len(activity_info1)}},
                     'stability': 'stable',
-                    'unpack_size': len(activity_info1),
                     },
                 },
             }, conn.get(['context', context, 'releases']))
@@ -109,10 +108,9 @@ class ContextTest(tests.Test):
                     'announce': next(volume['post'].find(query='title:1')[0]).guid,
                     'version': [[1], 0],
                     'requires': {},
-                    'commands': {'activity': {'exec': 'true'}},
-                    'spec': {'*-*': {'bundle': str(hash(bundle1))}},
+                    'command': 'true',
+                    'bundles': {'*-*': {'blob': str(hash(bundle1)), 'unpack_size': len(activity_info1)}},
                     'stability': 'stable',
-                    'unpack_size': len(activity_info1),
                     },
                 },
             release2: {
@@ -123,10 +121,9 @@ class ContextTest(tests.Test):
                     'announce': next(volume['post'].find(query='title:2')[0]).guid,
                     'version': [[2], 0],
                     'requires': {},
-                    'commands': {'activity': {'exec': 'true'}},
-                    'spec': {'*-*': {'bundle': str(hash(bundle2))}},
+                    'command': 'true',
+                    'bundles': {'*-*': {'blob': str(hash(bundle2)), 'unpack_size': len(activity_info2)}},
                     'stability': 'stable',
-                    'unpack_size': len(activity_info2),
                     },
                 },
             }, conn.get(['context', context, 'releases']))
@@ -147,10 +144,9 @@ class ContextTest(tests.Test):
                     'announce': next(volume['post'].find(query='title:2')[0]).guid,
                     'version': [[2], 0],
                     'requires': {},
-                    'commands': {'activity': {'exec': 'true'}},
-                    'spec': {'*-*': {'bundle': str(hash(bundle2))}},
+                    'command': 'true',
+                    'bundles': {'*-*': {'blob': str(hash(bundle2)), 'unpack_size': len(activity_info2)}},
                     'stability': 'stable',
-                    'unpack_size': len(activity_info2),
                     },
                 },
             }, conn.get(['context', context, 'releases']))
diff --git a/tests/units/model/model.py b/tests/units/model/model.py
index 28d8244..7649571 100755
--- a/tests/units/model/model.py
+++ b/tests/units/model/model.py
@@ -79,16 +79,18 @@ class ModelTest(tests.Test):
         self.assertEqual('developer', release['stability'])
         self.assertEqual(['Public Domain'], release['license'])
         self.assertEqual('developer', release['stability'])
-        self.assertEqual(
-                {'dep': {}, 'sugar': {'restrictions': [('0.88', None)]}},
-                release['requires'])
+        self.assertEqual({
+            'dep': [],
+            'sugar': [([1, 0], [[0, 88], 0])],
+            },
+            release['requires'])
         self.assertEqual({
             '*-*': {
-                'bundle': blob.digest,
+                'blob': blob.digest,
+                'unpack_size': len(activity_info) + len(changelog),
                 },
             },
-            release['spec'])
-        self.assertEqual(len(activity_info) + len(changelog), release['unpack_size'])
+            release['bundles'])
 
         post = volume['post'][release['announce']]
         assert tests.UID in post['author']
@@ -492,13 +494,13 @@ class ModelTest(tests.Test):
         context, release = load_bundle(blob, 'bundle_id')
 
         self.assertEqual({
-            'dep5': {'restrictions': [('40', None)]},
-            'dep4': {'restrictions': [('31', None)]},
-            'dep7': {'restrictions': [('1', '4')]},
-            'dep6': {'restrictions': [('6', '7')]},
-            'dep1': {},
-            'dep3': {'restrictions': [(None, '21')]},
-            'dep2': {'restrictions': [(None, '10')]},
+            'dep5': [([1, 0], [[40], 0])],
+            'dep4': [([1], [[30], 0])],
+            'dep7': [([1, 0], [[1], 0]), ([-1, 0], [[3], 0])],
+            'dep6': [([1], [[5], 0]), ([-1], [[7], 0])],
+            'dep1': [],
+            'dep3': [([-1, 0], [[20], 0])],
+            'dep2': [([-1], [[10], 0])],
             },
             release['requires'])
 
diff --git a/tests/units/node/model.py b/tests/units/node/model.py
index 13c1ef5..795b124 100755
--- a/tests/units/node/model.py
+++ b/tests/units/node/model.py
@@ -662,24 +662,24 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands1'}},
-                '2': {'value': {'stability': 'stable', 'version': 2, 'commands': 'commands2'}},
-                '3': {'value': {'stability': 'stable', 'version': 3, 'commands': 'commands3'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'commands1'}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0], 'command': 'commands2'}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0], 'command': 'commands3'}},
                 },
             })
         self.assertEqual(
-                {'commands': 'commands3', 'files': {context: '3'}, 'packages': {}},
+                {context: {'command': 'commands3', 'blob': '3', 'version': [[3], 0]}},
                 model.solve(volume, context))
 
         context = volume['context'].create({
             'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '3': {'value': {'stability': 'stable', 'version': 3, 'commands': 'commands3'}},
-                '2': {'value': {'stability': 'stable', 'version': 2, 'commands': 'commands2'}},
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands1'}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0], 'command': 'commands3'}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0], 'command': 'commands2'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'commands1'}},
                 },
             })
         self.assertEqual(
-                {'commands': 'commands3', 'files': {context: '3'}, 'packages': {}},
+                {context: {'command': 'commands3', 'blob': '3', 'version': [[3], 0]}},
                 model.solve(volume, context))
 
     def test_solve_SortByStability(self):
@@ -688,13 +688,13 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'developer', 'version': 1, 'commands': 'commands1'}},
-                '2': {'value': {'stability': 'stable', 'version': 2, 'commands': 'commands2'}},
-                '3': {'value': {'stability': 'buggy', 'version': 3, 'commands': 'commands3'}},
+                '1': {'value': {'stability': 'developer', 'version': [[1], 0], 'command': 'commands1'}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0], 'command': 'commands2'}},
+                '3': {'value': {'stability': 'buggy', 'version': [[3], 0], 'command': 'commands3'}},
                 },
             })
         self.assertEqual(
-                {'commands': 'commands2', 'files': {context: '2'}, 'packages': {}},
+                {context: {'command': 'commands2', 'blob': '2', 'version': [[2], 0]}},
                 model.solve(volume, context))
 
     def test_solve_CollectDeps(self):
@@ -705,9 +705,9 @@ class ModelTest(tests.Test):
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
                 '1': {'value': {
                     'stability': 'stable',
-                    'version': 1,
+                    'version': [[1], 0],
                     'requires': spec.parse_requires('context2; context4'),
-                    'commands': 'commands',
+                    'command': 'command',
                     }},
                 },
             })
@@ -715,26 +715,27 @@ class ModelTest(tests.Test):
             'guid': 'context2', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
                 '2': {'value': {
                     'stability': 'stable',
-                    'version': 2,
+                    'version': [[2], 0],
                     'requires': spec.parse_requires('context3'),
                     }},
                 },
             })
         volume['context'].create({
             'guid': 'context3', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '3': {'value': {'stability': 'stable', 'version': 3}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0]}},
                 },
             })
         volume['context'].create({
             'guid': 'context4', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '4': {'value': {'stability': 'stable', 'version': 4}},
+                '4': {'value': {'stability': 'stable', 'version': [[4], 0]}},
                 },
             })
 
         self.assertEqual({
-            'commands': 'commands',
-            'files': {'context3': '3', 'context2': '2', 'context1': '1', 'context4': '4'},
-            'packages': {},
+            'context1': {'blob': '1', 'version': [[1], 0], 'command': 'command'},
+            'context2': {'blob': '2', 'version': [[2], 0]},
+            'context3': {'blob': '3', 'version': [[3], 0]},
+            'context4': {'blob': '4', 'version': [[4], 0]},
             },
             model.solve(volume, 'context1'))
 
@@ -744,90 +745,103 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'dep', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': '1'}},
-                '2': {'value': {'stability': 'stable', 'version': '2'}},
-                '3': {'value': {'stability': 'stable', 'version': '3'}},
-                '4': {'value': {'stability': 'stable', 'version': '4'}},
-                '5': {'value': {'stability': 'stable', 'version': '5'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0]}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0]}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0]}},
+                '4': {'value': {'stability': 'stable', 'version': [[4], 0]}},
+                '5': {'value': {'stability': 'stable', 'version': [[5], 0]}},
                 },
             })
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep < 3'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '2', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '2', 'version': [[2], 0]},
+                },
                 model.solve(volume, 'context1'))
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep <= 3'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '3', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '3', 'version': [[3], 0]},
+                },
                 model.solve(volume, 'context1'))
 
-
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep > 2'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '5', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '5', 'version': [[5], 0]},
+                },
                 model.solve(volume, 'context1'))
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep >= 2'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '5', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '5', 'version': [[5], 0]},
+                },
                 model.solve(volume, 'context1'))
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep > 2; dep < 5'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '4', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '4', 'version': [[4], 0]},
+                },
                 model.solve(volume, 'context1'))
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep > 2; dep <= 3'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '3', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '3', 'version': [[3], 0]},
+                },
                 model.solve(volume, 'context1'))
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep = 1'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '1', 'context1': '10'}, 'commands': 'commands', 'packages': {}},
+        self.assertEqual({
+                'context1': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+                'dep': {'blob': '1', 'version': [[1], 0]},
+                },
                 model.solve(volume, 'context1'))
 
     def test_solve_SwitchToAlternativeBranch(self):
@@ -836,30 +850,32 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'context1', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '6': {'value': {'stability': 'stable', 'version': '1', 'requires': spec.parse_requires('context4=1'), 'commands': 'commands6'}},
-                '1': {'value': {'stability': 'stable', 'version': '2', 'requires': spec.parse_requires('context2'), 'commands': 'commands1'}},
+                '6': {'value': {'stability': 'stable', 'version': [[1], 0], 'requires': spec.parse_requires('context4=1'), 'command': 'commands6'}},
+                '1': {'value': {'stability': 'stable', 'version': [[2], 0], 'requires': spec.parse_requires('context2'), 'command': 'commands1'}},
                 },
             })
         volume['context'].create({
             'guid': 'context2', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '2': {'value': {'stability': 'stable', 'version': '1', 'requires': spec.parse_requires('context3; context4=1')}},
+                '2': {'value': {'stability': 'stable', 'version': [[1], 0], 'requires': spec.parse_requires('context3; context4=1')}},
                 },
             })
         volume['context'].create({
             'guid': 'context3', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '3': {'value': {'stability': 'stable', 'version': '1', 'requires': spec.parse_requires('context4=2')}},
+                '3': {'value': {'stability': 'stable', 'version': [[1], 0], 'requires': spec.parse_requires('context4=2')}},
                 },
             })
         volume['context'].create({
             'guid': 'context4', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '4': {'value': {'stability': 'stable', 'version': '2'}},
-                '5': {'value': {'stability': 'stable', 'version': '1'}},
+                '4': {'value': {'stability': 'stable', 'version': [[2], 0]}},
+                '5': {'value': {'stability': 'stable', 'version': [[1], 0]}},
                 },
             })
 
-        self.assertEqual(
-                {'files': {'context1': '6', 'context4': '5'}, 'commands': 'commands6', 'packages': {}},
-                model.solve(volume, 'context1'))
+        self.assertEqual({
+            'context1': {'blob': '6', 'version': [[1], 0], 'command': 'commands6'},
+            'context4': {'blob': '5', 'version': [[1], 0]},
+            },
+            model.solve(volume, 'context1'))
 
     def test_solve_CommonDeps(self):
         volume = db.Volume('master', [Context])
@@ -867,11 +883,11 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'dep', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': '1'}},
-                '2': {'value': {'stability': 'stable', 'version': '2'}},
-                '3': {'value': {'stability': 'stable', 'version': '3'}},
-                '4': {'value': {'stability': 'stable', 'version': '4'}},
-                '5': {'value': {'stability': 'stable', 'version': '5'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0]}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0]}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0]}},
+                '4': {'value': {'stability': 'stable', 'version': [[4], 0]}},
+                '5': {'value': {'stability': 'stable', 'version': [[5], 0]}},
                 },
             })
 
@@ -879,40 +895,46 @@ class ModelTest(tests.Test):
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {},
             'dependencies': 'dep=2',
             'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires(''),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '2', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            'dep': {'blob': '2', 'version': [[2], 0]},
+            },
+            model.solve(volume, 'context'))
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {},
             'dependencies': 'dep<5',
             'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep>1'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '4', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            'dep': {'blob': '4', 'version': [[4], 0]},
+            },
+            model.solve(volume, 'context'))
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {},
             'dependencies': 'dep<4',
             'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep<5'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '3', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            'dep': {'blob': '3', 'version': [[3], 0]},
+            },
+            model.solve(volume, 'context'))
 
     def test_solve_ExtraDeps(self):
         volume = db.Volume('master', [Context])
@@ -920,46 +942,51 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'dep', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': '1'}},
-                '2': {'value': {'stability': 'stable', 'version': '2'}},
-                '3': {'value': {'stability': 'stable', 'version': '3'}},
-                '4': {'value': {'stability': 'stable', 'version': '4'}},
-                '5': {'value': {'stability': 'stable', 'version': '5'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0]}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0]}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0]}},
+                '4': {'value': {'stability': 'stable', 'version': [[4], 0]}},
+                '5': {'value': {'stability': 'stable', 'version': [[5], 0]}},
                 },
             })
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires(''),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '2', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context', requires='dep=2'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            },
+            model.solve(volume, 'context'))
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep>1'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '4', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context', requires='dep<5'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            'dep': {'blob': '5', 'version': [[5], 0]},
+            },
+            model.solve(volume, 'context'))
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep<5'),
                     }},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '3', 'context': '10'}, 'commands': 'commands', 'packages': {}},
-                model.solve(volume, 'context', requires='dep<4'))
+        self.assertEqual({
+            'context': {'blob': '10', 'version': [[1], 0], 'command': 'command'},
+            'dep': {'blob': '4', 'version': [[4], 0]},
+            },
+            model.solve(volume, 'context'))
 
     def test_solve_Nothing(self):
         volume = db.Volume('master', [Context])
@@ -968,11 +995,11 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'dep', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': '1'}},
-                '2': {'value': {'stability': 'stable', 'version': '2'}},
-                '3': {'value': {'stability': 'stable', 'version': '3'}},
-                '4': {'value': {'stability': 'stable', 'version': '4'}},
-                '5': {'value': {'stability': 'stable', 'version': '5'}},
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0]}},
+                '2': {'value': {'stability': 'stable', 'version': [[2], 0]}},
+                '3': {'value': {'stability': 'stable', 'version': [[3], 0]}},
+                '4': {'value': {'stability': 'stable', 'version': [[4], 0]}},
+                '5': {'value': {'stability': 'stable', 'version': [[5], 0]}},
                 },
             })
 
@@ -984,7 +1011,7 @@ class ModelTest(tests.Test):
 
         volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '10': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '10': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep=0'),
                     }},
                 },
@@ -998,7 +1025,7 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('package'),
                     }},
                 },
@@ -1006,29 +1033,34 @@ class ModelTest(tests.Test):
         volume['context'].create({
             'guid': 'package', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
                 'resolves': {
-                    'Ubuntu-10.04': {'version': 1, 'packages': ['pkg1', 'pkg2']},
+                    'Ubuntu-10.04': {'version': [[1], 0], 'packages': ['pkg1', 'pkg2']},
                     },
                 },
             })
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package': ['pkg1', 'pkg2']}},
-                model.solve(volume, context, lsb_id='Ubuntu', lsb_release='10.04'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package': {'packages': ['pkg1', 'pkg2'], 'version': [[1], 0]},
+            },
+            model.solve(volume, context, lsb_id='Ubuntu', lsb_release='10.04'))
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('dep; package'),
                     }},
                 },
             })
         volume['context'].create({
             'guid': 'dep', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '2': {'value': {'stability': 'stable', 'version': '1'}},
+                '2': {'value': {'stability': 'stable', 'version': [[1], 0]}},
                 },
             })
-        self.assertEqual(
-                {'files': {'dep': '2', 'context': '1'}, 'commands': 'commands', 'packages': {'package': ['pkg1', 'pkg2']}},
-                model.solve(volume, context, lsb_id='Ubuntu', lsb_release='10.04'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'dep': {'blob': '2', 'version': [[1], 0]},
+            'package': {'packages': ['pkg1', 'pkg2'], 'version': [[1], 0]},
+            },
+            model.solve(volume, context, lsb_id='Ubuntu', lsb_release='10.04'))
 
     def test_solve_PackagesByLsbId(self):
         volume = db.Volume('master', [Context])
@@ -1037,7 +1069,7 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('package1'),
                     }},
                 },
@@ -1047,13 +1079,15 @@ class ModelTest(tests.Test):
                 'Ubuntu': {'value': {'binary': ['bin1', 'bin2'], 'devel': ['devel1', 'devel2']}},
                 },
             })
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package1': ['bin1', 'bin2', 'devel1', 'devel2']}},
-                model.solve(volume, context, lsb_id='Ubuntu'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package1': {'packages': ['bin1', 'bin2', 'devel1', 'devel2'], 'version': []},
+            },
+            model.solve(volume, context, lsb_id='Ubuntu'))
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('package2'),
                     }},
                 },
@@ -1062,13 +1096,15 @@ class ModelTest(tests.Test):
             'guid': 'package2', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
                 'Ubuntu': {'value': {'binary': ['bin']}},
                 'resolves': {
-                    'Ubuntu-10.04': {'version': 1, 'packages': ['pkg1', 'pkg2']},
+                    'Ubuntu-10.04': {'version': [[1], 0], 'packages': ['pkg1', 'pkg2']},
                     },
                 },
             })
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package2': ['bin']}},
-                model.solve(volume, context, lsb_id='Ubuntu', lsb_release='fake'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package2': {'packages': ['bin'], 'version': []},
+            },
+            model.solve(volume, context, lsb_id='Ubuntu', lsb_release='fake'))
 
     def test_solve_PackagesByCommonAlias(self):
         volume = db.Volume('master', [Context])
@@ -1077,7 +1113,7 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('package1'),
                     }},
                 },
@@ -1087,19 +1123,25 @@ class ModelTest(tests.Test):
                 '*': {'value': {'binary': ['pkg1']}},
                 'Ubuntu': {'value': {'binary': ['pkg2']}},
                 'resolves': {
-                    'Ubuntu-10.04': {'version': 1, 'packages': ['pkg3']},
+                    'Ubuntu-10.04': {'version': [[1], 0], 'packages': ['pkg3']},
                     },
                 },
             })
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package1': ['pkg1']}},
-                model.solve(volume, context))
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package1': ['pkg1']}},
-                model.solve(volume, context, lsb_id='Fake'))
-        self.assertEqual(
-                {'files': {'context': '1'}, 'commands': 'commands', 'packages': {'package1': ['pkg1']}},
-                model.solve(volume, context, lsb_id='Fake', lsb_release='fake'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package1': {'packages': ['pkg1'], 'version': []},
+            },
+            model.solve(volume, context))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package1': {'packages': ['pkg1'], 'version': []},
+            },
+            model.solve(volume, context, lsb_id='Fake'))
+        self.assertEqual({
+            'context': {'blob': '1', 'command': 'command', 'version': [[1], 0]},
+            'package1': {'packages': ['pkg1'], 'version': []},
+            },
+            model.solve(volume, context, lsb_id='Fake', lsb_release='fake'))
 
     def test_solve_NoPackages(self):
         volume = db.Volume('master', [Context])
@@ -1108,7 +1150,7 @@ class ModelTest(tests.Test):
 
         context = volume['context'].create({
             'guid': 'context', 'type': ['activity'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                '1': {'value': {'stability': 'stable', 'version': 1, 'commands': 'commands',
+                '1': {'value': {'stability': 'stable', 'version': [[1], 0], 'command': 'command',
                     'requires': spec.parse_requires('package'),
                     }},
                 },
diff --git a/tests/units/node/node.py b/tests/units/node/node.py
index 025a0c0..2c8ab8a 100755
--- a/tests/units/node/node.py
+++ b/tests/units/node/node.py
@@ -560,10 +560,9 @@ class NodeTest(tests.Test):
                     'announce': announce,
                     'version': [[1], 0],
                     'requires': {},
-                    'spec': {'*-*': {'bundle': str(hash(bundle))}},
-                    'commands': {'activity': {'exec': 'true'}},
+                    'bundles': {'*-*': {'blob': str(hash(bundle)), 'unpack_size': len(activity_info) + len(changelog)}},
+                    'command': 'true',
                     'stability': 'developer',
-                    'unpack_size': len(activity_info) + len(changelog),
                     },
                 },
             }, conn.get(['context', 'bundle_id', 'releases']))
@@ -617,9 +616,9 @@ class NodeTest(tests.Test):
         conn.put(['context', 'package', 'releases', '*'], {'binary': ['package.bin']})
 
         self.assertEqual({
-            'commands': {'activity': {'exec': 'true'}},
-            'files': {'dep': dep_file, 'activity': activity_file},
-            'packages': {'package': ['package.bin']},
+            'activity': {'blob': activity_file, 'command': 'true', 'version': [[1], 0]},
+            'dep': {'blob': dep_file, 'version': [[2], 0]},
+            'package': {'packages': ['package.bin'], 'version': []},
             },
             conn.get(['context', 'activity'], cmd='solve'))
 
@@ -671,14 +670,14 @@ class NodeTest(tests.Test):
             })
         volume['context'].update('package', {'releases': {
             'resolves': {
-                'Ubuntu-10.04': {'version': 1, 'packages': ['package.bin']},
-                'Ubuntu-12.04': {'version': 2, 'packages': ['package-fake.bin']},
+                'Ubuntu-10.04': {'version': [[1], 0], 'packages': ['package.bin']},
+                'Ubuntu-12.04': {'version': [[2], 0], 'packages': ['package-fake.bin']},
             }}})
 
         self.assertEqual({
-            'commands': {'activity': {'exec': 'true'}},
-            'files': {'dep': dep_file, 'activity': activity_file},
-            'packages': {'package': ['package.bin']},
+            'activity': {'blob': activity_file, 'command': 'true', 'version': [[1], 0]},
+            'dep': {'blob': dep_file, 'version': [[2], 0]},
+            'package': {'packages': ['package.bin'], 'version': [[1], 0]},
             },
             conn.get(['context', 'activity'], cmd='solve',
                 stability='developer', lsb_id='Ubuntu', lsb_release='10.04', requires=['dep', 'package']))
diff --git a/tests/units/toolkit/spec.py b/tests/units/toolkit/spec.py
index 89d04b3..7c7188e 100755
--- a/tests/units/toolkit/spec.py
+++ b/tests/units/toolkit/spec.py
@@ -10,58 +10,23 @@ from sugar_network.toolkit import spec
 
 class SpecTest(tests.Test):
 
-    def test_Dependency_versions_range(self):
-        self.assertEqual(
-                [],
-                [i for i in spec._Dependency().versions_range()])
-        self.assertEqual(
-                [],
-                [i for i in spec._Dependency({'restrictions': []}).versions_range()])
-        self.assertEqual(
-                [],
-                [i for i in spec._Dependency({'restrictions': [(None, '2')]}).versions_range()])
-        self.assertEqual(
-                ['1'],
-                [i for i in spec._Dependency({'restrictions': [('1', None)]}).versions_range()])
-        self.assertEqual(
-                ['1'],
-                [i for i in spec._Dependency({'restrictions': [('1', '2')]}).versions_range()])
-        self.assertEqual(
-                ['1.2'],
-                [i for i in spec._Dependency({'restrictions': [('1.2', '1.2.999')]}).versions_range()])
-        self.assertEqual(
-                ['1.2', '1.3'],
-                [i for i in spec._Dependency({'restrictions': [('1.2', '1.4')]}).versions_range()])
-        self.assertEqual(
-                ['1.2.3', '1.3'],
-                [i for i in spec._Dependency({'restrictions': [('1.2.3', '1.4')]}).versions_range()])
-        self.assertEqual(
-                ['1.2', '1.3', '1.4'],
-                [i for i in spec._Dependency({'restrictions': [('1.2', '1.4.5')]}).versions_range()])
-
     def test_parse_requires(self):
-        self.assertEqual(
-                {'a': {}, 'b': {}, 'c': {}},
-                spec.parse_requires('a; b; c'))
-
-        self.assertEqual(
-                {
-                    'a': {'restrictions': [('1', '2')]},
-                    'b': {'restrictions': [('1.2', '1.3')]},
-                    'c': {'restrictions': [('2.2', None)]},
-                    'd': {'restrictions': [(None, '3')]},
-                    'e': {'restrictions': [('5', None)]},
-                    'f': {'restrictions': [(None, '6')]},
-                    },
-                spec.parse_requires('a = 1; b=1.2; c>= 2.2; d <3-3; e > 4; f<=5'))
-
-        self.assertEqual(
-                {
-                    'a': {'importance': 'recommended'},
-                    'b': {},
-                    'c': {'importance': 'recommended', 'restrictions': [(None, '1')]},
-                    },
-                spec.parse_requires('[a]; b; [c<1]'))
+        self.assertEqual({
+            'a': [],
+            'b': [],
+            'c': [],
+            },
+            spec.parse_requires('a; b; c'))
+
+        self.assertEqual({
+            'a': [([0],     [[1], 0])],
+            'b': [([0],     [[1, 2], 0])],
+            'c': [([1, 0],  [[2, 2, 2], 0])],
+            'd': [([-1],    [[3], 0])],
+            'e': [([1],     [[4], 0])],
+            'f': [([-1, 0], [[5], 0])],
+            },
+            spec.parse_requires('a = 1; b==1.2; c>= 2.2.2; d <3-rc1; e > 4; f<=5'))
 
     def test_parse_bindings(self):
         self.assertEqual(
@@ -114,19 +79,12 @@ class SpecTest(tests.Test):
         self.assertEqual(['terminal', 'console'], recipe['tags'])
         self.assertEqual(['image/png', 'image/svg+xml'], recipe['mime_types'])
         self.assertEqual(
-                {
-                    'activity': {
-                        'exec': 'sugar-activity terminal.TerminalActivity',
-                        },
-                    },
-                recipe.commands)
-        self.assertEqual(
-                {
-                    'sugar': {
-                        'restrictions': [('0.94', '0.95')],
-                        },
-                    },
-                recipe.requires)
+                'sugar-activity terminal.TerminalActivity',
+                recipe.command)
+        self.assertEqual({
+            'sugar': [([0], [[0, 94], 0])],
+            },
+            recipe.requires)
 
     def test_parse_version(self):
 
@@ -179,39 +137,41 @@ class SpecTest(tests.Test):
     def test_parse_version_IgnoreErrors(self):
         self.assertEqual([[1, 2], 0], spec.parse_version('1.2foo', ignore_errors=True))
 
-    def test_ensure_requires(self):
-        assert spec.ensure_requires(spec.parse_requires(''), spec.parse_requires(''))
-
-        assert not spec.ensure_requires(spec.parse_requires(''), spec.parse_requires('d1'))
-        assert spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires(''))
-        assert spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires('d1'))
-
-        assert not spec.ensure_requires(spec.parse_requires(''), spec.parse_requires('d1; d2'))
-        assert spec.ensure_requires(spec.parse_requires('d1; d2'), spec.parse_requires(''))
-        assert not spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires('d1; d2'))
-        assert spec.ensure_requires(spec.parse_requires('d1; d2'), spec.parse_requires('d1'))
-        assert spec.ensure_requires(spec.parse_requires('d1; d2'), spec.parse_requires('d1; d2'))
-
-        assert spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires('d1 < 1'))
-        assert spec.ensure_requires(spec.parse_requires('d1 < 1'), spec.parse_requires('d1'))
-        assert spec.ensure_requires(spec.parse_requires('d1 < 1'), spec.parse_requires('d1 < 2'))
-        assert spec.ensure_requires(spec.parse_requires('d1 < 2'), spec.parse_requires('d1 < 1'))
-
-        assert spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires('d1 > 1'))
-        assert spec.ensure_requires(spec.parse_requires('d1 > 1'), spec.parse_requires('d1'))
-        assert spec.ensure_requires(spec.parse_requires('d1 > 1'), spec.parse_requires('d1 > 2'))
-        assert spec.ensure_requires(spec.parse_requires('d1 > 2'), spec.parse_requires('d1 > 1'))
-
-        assert spec.ensure_requires(spec.parse_requires('d1'), spec.parse_requires('d1 > 1; d1 < 2'))
-        assert spec.ensure_requires(spec.parse_requires('d1 > 1; d1 < 2'), spec.parse_requires('d1'))
-        # Commented until implementing precice version comparation
-        #assert spec.ensure_requires(spec.parse_requires('d1 > 1; d1 < 2'), spec.parse_requires('d1 > 0; d1 < 3'))
-        #assert spec.ensure_requires(spec.parse_requires('d1 > 0; d1 < 3'), spec.parse_requires('d1 > 1; d1 < 2'))
-
-        assert spec.ensure_requires(spec.parse_requires('d1 > 1; d1 <= 2'), spec.parse_requires('d1 >= 2; d1 < 3'))
-        assert spec.ensure_requires(spec.parse_requires('d1 >= 1; d1 < 2'), spec.parse_requires('d1 > 0; d1 <= 1'))
-        assert not spec.ensure_requires(spec.parse_requires('d1 > 1; d1 < 2'), spec.parse_requires('d1 > 2; d1 < 3'))
-        assert not spec.ensure_requires(spec.parse_requires('d1 > 1; d1 < 2'), spec.parse_requires('d1 > 0; d1 < 1'))
+    def test_ensure(self):
+        assert spec.ensure(spec.parse_version('1'), spec.parse_requires('dep')['dep'])
+
+        assert spec.ensure(spec.parse_version('1'), spec.parse_requires('dep=1')['dep'])
+        assert not spec.ensure(spec.parse_version('2'), spec.parse_requires('dep=1')['dep'])
+
+        assert spec.ensure(spec.parse_version('1'), spec.parse_requires('dep<2')['dep'])
+        assert not spec.ensure(spec.parse_version('2'), spec.parse_requires('dep<2')['dep'])
+        assert not spec.ensure(spec.parse_version('3'), spec.parse_requires('dep<2')['dep'])
+
+        assert spec.ensure(spec.parse_version('3'), spec.parse_requires('dep>2')['dep'])
+        assert not spec.ensure(spec.parse_version('2'), spec.parse_requires('dep>2')['dep'])
+        assert not spec.ensure(spec.parse_version('1'), spec.parse_requires('dep>2')['dep'])
+
+        assert spec.ensure(spec.parse_version('1'), spec.parse_requires('dep<=2')['dep'])
+        assert spec.ensure(spec.parse_version('2'), spec.parse_requires('dep<=2')['dep'])
+        assert not spec.ensure(spec.parse_version('3'), spec.parse_requires('dep<=2')['dep'])
+
+        assert spec.ensure(spec.parse_version('3'), spec.parse_requires('dep>=2')['dep'])
+        assert spec.ensure(spec.parse_version('2'), spec.parse_requires('dep>=2')['dep'])
+        assert not spec.ensure(spec.parse_version('1'), spec.parse_requires('dep>=2')['dep'])
+
+    def test_ensure_StripVersionsForEQ(self):
+        assert spec.ensure(spec.parse_version('1.2'), spec.parse_requires('dep=1')['dep'])
+        assert not spec.ensure(spec.parse_version('1'), spec.parse_requires('dep=1.2')['dep'])
+        assert spec.ensure(spec.parse_version('1.2.3'), spec.parse_requires('dep=1.2')['dep'])
+
+        assert spec.ensure(spec.parse_version('1-pre2'), spec.parse_requires('dep=1')['dep'])
+        assert spec.ensure(spec.parse_version('1-post2'), spec.parse_requires('dep=1')['dep'])
+
+        assert spec.ensure(spec.parse_version('1.2-pre3'), spec.parse_requires('dep=1')['dep'])
+        assert spec.ensure(spec.parse_version('1.2-post3'), spec.parse_requires('dep=1')['dep'])
+
+        assert not spec.ensure(spec.parse_version('1-pre3'), spec.parse_requires('dep=1.2')['dep'])
+        assert not spec.ensure(spec.parse_version('1-post3'), spec.parse_requires('dep=1.2')['dep'])
 
 
 if __name__ == '__main__':