Merge branch 'master' of git://git.sugarlabs.org/tutorius/mainline

7 files changed, 600 insertions, 86 deletions

diff --git a/tests/addontests.py b/tests/addontests.py
new file mode 100644
index 0000000..5fb4f61
--- /dev/null
+++ b/tests/addontests.py
@@ -0,0 +1,50 @@
+# Copyright (C) 2009, Tutorius.org
+# Copyright (C) 2009, Simon Poirier <simpoir@gmail.com>
+#
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+import unittest
+
+from sugar.tutorius import addon
+
+class AddonTest(unittest.TestCase):
+    def test_create_constructor_fail(self):
+        try:
+            obj = addon.create("BubbleMessage", wrong_param=True, second_wrong="This", last_wrong=12, unknown=13.4)
+            assert False, "Constructor with wrong parameter should raise an exception"
+        except:
+            pass
+
+    def test_create_wrong_addon(self):
+        try:
+            obj = addon.create("Non existing addon name")
+            assert False, "Addon creator should raise an exception when the requested addon is unknown"
+        except:
+            pass
+
+    def test_create(self):
+        obj = addon.create("BubbleMessage", message="Hi!", position=[12,31])
+
+        assert obj is not None
+
+    def test_reload_addons(self):
+        addon._cache = None
+        assert len(addon.list_addons()) > 0, "Addons should be reloaded upon cache clear"
+
+    def test_get_addon_meta(self):
+        addon._cache = None
+        meta = addon.get_addon_meta("BubbleMessage")
+        assert meta.keys() == ['mandatory_props', 'class', 'display_name', 'name', 'icon',]
diff --git a/tests/coretests.py b/tests/coretests.py
index f90374f..4f564c8 100644
--- a/tests/coretests.py
+++ b/tests/coretests.py
@@ -28,6 +28,7 @@ and event filters. Those are in their separate test module
 
 import unittest
 
+import copy
 import logging
 from sugar.tutorius.actions import *
 from sugar.tutorius.addon import *
@@ -49,6 +50,28 @@ class SimpleTutorial(Tutorial):
     def set_state(self, name):
         self.current_state_name = name
 
+class TutorialTest(unittest.TestCase):
+    """Tests the tutorial functions that are not covered elsewhere."""
+    def test_detach(self):
+        class Activity(object):
+            name = "this"
+
+        activity1 = Activity()
+        activity2 = Activity()
+
+        fsm = FiniteStateMachine("Sample example")
+        
+        tutorial = Tutorial("Test tutorial", fsm)
+
+        assert tutorial.activity == None, "There is a default activity in the tutorial"
+
+        tutorial.attach(activity1)
+
+        assert tutorial.activity == activity1, "Activity should have been associated to this tutorial"
+
+        tutorial.attach(activity2)
+        assert tutorial.activity == activity2, "Activity should have been changed to activity2"
+
 class TutorialWithFSM(Tutorial):
     """
     Fake tutorial, but associated with a FSM.
@@ -159,14 +182,11 @@ class StateTest(unittest.TestCase):
         assert state.add_action(act2), "Could not add the second action"
         assert state.add_action(act3), "Could not add the third action"
         
-        # Try to add a second time an action that was already inserted
-        assert state.add_action(act1) == False, "Not supposed to insert an action twice"
-        
         # Fetch the associated actions
         actions = state.get_action_list()
         
         # Make sure all the actions are present in the state
-        assert act1 in actions and act2 in actions and act3 in actions,\
+        assert act1 in actions and act2 in actions and act3 in actions, \
             "The actions were not properly inserted in the state"
         
         # Clear the list
@@ -201,7 +221,80 @@ class StateTest(unittest.TestCase):
         
         assert len(state.get_event_filter_list()) == 0, \
             "Could not clear the event filter list properly"
+
+    def test_eq_simple(self):
+        """
+        Two empty states with the same name must be identical
+        """
+        st1 = State("Identical")
+        st2 = State("Identical")
+
+        assert st1 == st2, "Empty states with the same name should be identical"
+
+    def test_eq(self):
+        """
+        Test whether two states share the same set of actions and event filters.
+        """
+        st1 = State("Identical")
+        st2 = State("Identical")
+
+        non_state = object()
+
+        act1 = addon.create("BubbleMessage", message="Hi", position=[132,450])
+        act2 = addon.create("BubbleMessage", message="Hi", position=[132,450])
+
+        event1 = addon.create("GtkWidgetEventFilter", "nextState", "0.0.0.1.1.2.3.1", "clicked")
+
+        act3 = addon.create("DialogMessage", message="Hello again.", position=[200, 400])
+
+        # Build the first state
+        st1.add_action(act1)
+        st1.add_action(act3)
+        st1.add_event_filter(event1)
+
+        # Build the second state
+        st2.add_action(act2)
+        st2.add_action(act3)
+        st2.add_event_filter(event1)
+
+        # Make sure that they are identical for now
+        assert st1 == st2, "States should be considered as identical"
+        assert st2 == st1, "States should be considered as identical"
     
+        # Modify the second bubble message action
+        act2.message = "New message"
+
+        # Since one action changed in the second state, this should indicate that the states
+        # are not identical anymore
+        assert not (st1 == st2), "Action was changed and states should be different"
+        assert not (st2 == st1), "Action was changed and states should be different"
+
+        # Make sure that trying to find identity with something else than a State object fails properly
+        assert not (st1 == non_state), "Passing a non-State object should fail for identity"
+        
+        st2.name = "Not identical anymore"
+        assert not(st1 == st2), "Different state names should give different states"
+        st2.name = "Identical"
+
+        st3 = copy.deepcopy(st1)
+        st3.add_action(addon.create("BubbleMessage", "Hi!", [128,264]))
+
+        assert not (st1 == st3), "States having a different number of actions should be different"
+
+        st4 = copy.deepcopy(st1)
+        st4.add_event_filter(addon.create("GtkWidgetEventFilter", "next_state", "0.0.1.1.2.2.3", "clicked"))
+
+        assert not (st1 == st4), "States having a different number of events should be different"
+
+        st5 = copy.deepcopy(st1)
+        st5._event_filters = []
+    
+        st5.add_event_filter(addon.create("GtkWidgetEventFilter", "other_state", "0.1.2.3.4.1.2", "pressed"))
+
+        #import rpdb2; rpdb2.start_embedded_debugger('pass')
+        assert not (st1 == st5), "States having the same number of event filters" \
+             + " but those being different should be different"
+
 class FSMTest(unittest.TestCase):
     """
     This class needs to text the interface and functionality of the Finite 
@@ -246,6 +339,7 @@ class FSMTest(unittest.TestCase):
         assert act_second.active == False, "FSM did not teardown SECOND properly"
         
     
+    
     def test_state_insert(self):
         """
         This is a simple test to insert, then find a state.
@@ -337,10 +431,10 @@ class FSMTest(unittest.TestCase):
         
         # Make sure that there is no link to the removed state in the rest
         # of the FSM
-        assert "second" not in fsm.get_following_states("INIT"),\
+        assert "second" not in fsm.get_following_states("INIT"), \
             "The link to second from INIT still exists after removal"
         
-        assert "second" not in fsm.get_following_states("third"),\
+        assert "second" not in fsm.get_following_states("third"), \
             "The link to second from third still exists after removal"
     
     def test_set_same_state(self):
@@ -367,8 +461,116 @@ class FSMTest(unittest.TestCase):
             "The action was triggered a second time, do_count = %d"%do_count
         
         undo_count = fsm.get_state_by_name("INIT").get_action_list()[0].undo_count
-        assert fsm.get_state_by_name("INIT").get_action_list()[0].undo_count == 0,\
+        assert fsm.get_state_by_name("INIT").get_action_list()[0].undo_count == 0, \
             "The action has been undone unappropriately, undo_count = %d"%undo_count
+
+    def test_setup(self):
+        fsm = FiniteStateMachine("New state machine")
+        
+        try:
+            fsm.setup()
+            assert False, "fsm should throw an exception when trying to setup and not bound to a tutorial"
+        except UnboundLocalError:
+            pass    
+
+    def test_setup_actions(self):
+        tut = SimpleTutorial()
+
+        states_dict = {"INIT": State("INIT")}
+        fsm = FiniteStateMachine("New FSM", state_dict=states_dict)
+
+        act = CountAction()
+        fsm.add_action(act)
+
+        fsm.set_tutorial(tut)
+        
+        fsm.setup()
+
+        # Let's also test the current state name
+        assert fsm.get_current_state_name() == "INIT", "Initial state should be INIT"
+
+        assert act.do_count == 1, "Action should have been called during setup"
+
+        fsm._fsm_has_finished = True
+
+        fsm.teardown()
+
+        assert act.undo_count == 1, "Action should have been undone"
+
+    def test_string_rep(self):
+        fsm = FiniteStateMachine("Testing machine")
+
+        st1 = State("INIT")
+        st2 = State("Other State")
+        st3 = State("Final State")
+
+        st1.add_action(addon.create("BubbleMessage", "Hi!", [132,312]))
+
+        fsm.add_state(st1)
+        fsm.add_state(st2)
+        fsm.add_state(st3)
+
+        assert str(fsm) == "INIT, Final State, Other State, "
+        
+    def test_eq_(self):
+        fsm = FiniteStateMachine("Identity test")
+
+        non_fsm_object = object()
+        
+        assert not (fsm == non_fsm_object), "Testing with non FSM object should not give identity"
+        
+        # Compare FSMs
+        act1 = CountAction()
+
+        fsm.add_action(act1)
+
+        fsm2 = copy.deepcopy(fsm)
+
+        assert fsm == fsm2
+
+        act2 = CountAction()
+        fsm2.add_action(act2)
+
+        assert not(fsm == fsm2), \
+            "FSMs having a different number of actions should be different"
+
+        fsm3 = FiniteStateMachine("Identity test")
+
+        act3 = addon.create("BubbleMessage", "Hi!", [123,312])
+        fsm3.add_action(act3)
+        
+        assert not(fsm3 == fsm), \
+            "Actions having the same number of actions but different ones should be different"
+
+        st1 = State("INIT")
+        
+        st2 = State("OtherState")
+
+        fsm.add_state(st1)
+        fsm.add_state(st2)
+
+        fsm4 = copy.deepcopy(fsm)
+
+        assert fsm == fsm4
+
+        st3 = State("Last State")
+
+        fsm4.add_state(st3)
+
+        assert not (fsm == fsm4), "FSMs having a different number of states should not be identical"
+
+        fsm4.remove_state("OtherState")
+
+        assert not (fsm == fsm4), "FSMs having different states should be different"
+        
+        fsm4.remove_state("Last State")
+        
+        st5 = State("OtherState")
+        st5.add_action(CountAction())
+
+        fsm4.add_state(st5)
+
+        assert not(fsm == fsm4), "FSMs having states with same name but different content should be different"
     
 class FSMExplorationTests(unittest.TestCase):
     def setUp(self):
@@ -425,6 +627,5 @@ class FSMExplorationTests(unittest.TestCase):
         
         self.validate_previous_states("Fourth", ("Second"))
         
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/probetests.py b/tests/probetests.py
new file mode 100644
index 0000000..a440334
--- /dev/null
+++ b/tests/probetests.py
@@ -0,0 +1,63 @@
+# Copyright (C) 2009, Tutorius.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+"""
+Probe Tests
+
+"""
+
+import unittest
+import os, sys
+import gtk
+import time
+
+from dbus.mainloop.glib import DBusGMainLoop
+import dbus
+
+from sugar.tutorius.TProbe import TProbe, ProbeProxy
+
+
+class FakeActivity(object):
+    def __init__(self):
+        self.top = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
+        self.top.set_name("Top")
+        
+        hbox = gtk.HBox()
+        self.top.add(hbox)
+        hbox.show()
+
+        btn1 = gtk.Button()
+        btn1.set_name("Button1")
+        hbox.pack_start(btn1)
+        btn1.show()
+        self.button = btn1
+
+class ProbeTest(unittest.TestCase):
+    def test_ping(self):
+        m = DBusGMainLoop(set_as_default=True)
+        dbus.set_default_main_loop(m)
+
+        activity = FakeActivity()
+        probe = TProbe("localhost.unittest.ProbeTest", activity.top)
+
+        #Parent, ping the probe
+        proxy = ProbeProxy("localhost.unittest.ProbeTest")
+        res = probe.ping()
+        
+        assert res == "alive", "Probe should be alive"
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/propertiestests.py b/tests/propertiestests.py
index e1f6f4b..0b8251a 100644
--- a/tests/propertiestests.py
+++ b/tests/propertiestests.py
@@ -17,6 +17,7 @@
 import unittest
 import uuid
 import os
+import copy
 
 from sugar.tutorius.constraints import *
 from sugar.tutorius.properties import *
@@ -83,7 +84,128 @@ class BasePropertyTest(unittest.TestCase):
         obj.prop = 2
         
         assert obj.prop == 2, "Unable to set a value on base class"
+
+    def test_eq_(self):
+        class klass(TPropContainer):
+            prop = TutoriusProperty()
+        obj = klass()
+
+        obj2 = klass()
+
+        assert obj == obj2, "Base property containers should be identical"
     
+class AdvancedPropertyTest(unittest.TestCase):
+    def test_properties_groups(self):
+        """
+        Tests complex properties containers for identity.
+        """
+        
+        class klass1(TPropContainer):
+            message = TutoriusProperty()
+            property = TutoriusProperty()
+            data = TutoriusProperty()
+
+        class klass3(TPropContainer):
+            property = TutoriusProperty()
+            message = TutoriusProperty()
+            data = TutoriusProperty()
+            extra_prop = TutoriusProperty()
+
+        class klass4(TPropContainer):
+            property = TutoriusProperty()
+            message = TutoriusProperty()
+            data = TFloatProperty(13.0)
+
+        obj1 = klass1()
+        obj1.property = 12
+        obj1.message = "Initial message"
+        obj1.data = [132, 208, 193, 142]
+
+        obj2 = klass1()
+        obj2.property = 12
+        obj2.message = "Initial message"
+        obj2.data = [132, 208, 193, 142]
+
+        obj3 = klass3()
+        obj3.property = 12
+        obj3.message = "Initial message"
+        obj3.data = [132, 208, 193, 142]
+        obj3.extra_prop = "Suprprise!"
+
+        obj4 = klass4()
+        obj4.property = 12
+        obj4.message = "Initial message"
+        obj4.data = 13.4
+
+        # Ensure that both obj1 and obj2 are identical (they have the same list of
+        # properties and they have the same values
+        assert obj1 == obj1, "Identical objects were considered as different"
+
+        # Ensure that obj1 is different from obj3, since obj3 has an extra property
+        assert not (obj1 == obj3), "Objects should not be identical since obj3 has more props"
+        assert not (obj3 == obj1), "Objects should not be identical since obj3 has more properties"
+
+        # Ensure that properties of different type are considered as different
+        assert not (obj1 == obj4), "Properties of different type should not be equal"
+
+    def test_addon_properties(self):
+        """Test an addon property.
+
+        This tests creates a class with a single addon property (klass1) and 
+        assigns a new addon to it (inner1)."""
+        class klass1(TPropContainer):
+            addon = TAddonProperty()
+
+        class inner1(TPropContainer):
+            internal = TutoriusProperty()
+            def __init__(self, value):
+                TPropContainer.__init__(self)
+                self.internal = value
+        
+        obj1 = klass1()
+        obj1.addon = inner1("Hi!")
+
+        obj2 = klass1()
+        obj2.addon = inner1("Hi!")
+
+        assert obj1 == obj2, "Identical objects with addon properties were treated as different"
+
+        obj3 = klass1()
+        obj3.addon = inner1("Hello!")
+
+        assert not (obj1 == obj3), "Objects with addon property having a different value should be considered different"        
+
+    def test_addonlist_properties(self):
+        class klass1(TPropContainer):
+            addon_list = TAddonListProperty()
+
+        class inner1(TPropContainer):
+            message = TutoriusProperty()
+            data = TutoriusProperty()
+            def __init__(self, message, data):
+                TPropContainer.__init__(self)
+                self.message = message
+                self.data = data
+
+        class inner2(TPropContainer):
+            message = TutoriusProperty()
+            other_data = TutoriusProperty()
+            def __init__(self, message, data):
+                TPropContainer.__init__(self)
+                self.message = message
+                self.other_data = data
+
+        obj1 = klass1()
+        obj1.addon_list = [inner1('Hi!', 12), inner1('Hello.', [1,2])]
+        obj2 = klass1()
+        obj2.addon_list = [inner1('Hi!', 12), inner1('Hello.', [1,2])]
+
+        assert obj1 == obj2, "Addon lists with the same containers were considered different"
+
+        obj3 = klass1()
+        obj3.addon_list = [inner1('Hi!', 12), inner2('Hello.', [1,2])]
+        assert not (obj1 == obj3), "Differently named properties should be considered different in the addon list tests"
+
 class TIntPropertyTest(unittest.TestCase):
     def test_int_property(self):
         class klass(TPropContainer):
@@ -379,12 +501,18 @@ class TEnumPropertyTest(unittest.TestCase):
         try_wrong_values(self.obj)
     
 class TFilePropertyTest(unittest.TestCase):
+    root_folder = "/tmp/tutorius"
+
     def setUp(self):
+        try:
+            os.mkdir(self.root_folder)
+        except:
+            pass
         # Create some sample, unique files for the tests
-        self.temp_filename1 = "sample_file1_" + str(uuid.uuid1())  + ".txt"
+        self.temp_filename1 = os.path.join(self.root_folder, "sample_file1_" + str(uuid.uuid1())  + ".txt")
         self.temp_file1 = file(self.temp_filename1, "w")
         self.temp_file1.close()
-        self.temp_filename2 = "sample_file2_" + str(uuid.uuid1())  + ".txt"
+        self.temp_filename2 = os.path.join(self.root_folder, "sample_file2_" + str(uuid.uuid1())  + ".txt")
         self.temp_file2 = file(self.temp_filename2, "w")
         self.temp_file2.close()
 
@@ -412,6 +540,45 @@ class TFilePropertyTest(unittest.TestCase):
         except FileConstraintError:
             pass
 
+class TAddonPropertyTest(unittest.TestCase):
+    def test_wrong_value(self):
+        class klass1(TPropContainer):
+            addon = TAddonProperty()
+
+        class wrongAddon(object):
+            pass
+        
+        obj1 = klass1()
+        obj1.addon = klass1()
+        
+        try:
+            obj1.addon = wrongAddon()
+            assert False, "Addon Property should not accept non-TPropContainer values"
+        except ValueError:
+            pass
+
+class TAddonPropertyList(unittest.TestCase):
+    def test_wrong_value(self):
+        class klass1(TPropContainer):
+            addonlist = TAddonListProperty()
+
+        class wrongAddon(object):
+            pass
+
+        obj1 = klass1()
+
+        obj1.addonlist = [klass1(), klass1()]
+
+        try:
+            obj1.addonlist = klass1()
+            assert False, "TAddonPropeprty shouldn't accept anything else than a list"
+        except ValueError:
+            pass
+
+        try:
+            obj1.addonlist = [klass1(), klass1(), wrongAddon(), klass1()]
+        except ValueError:
+            pass
 if __name__ == "__main__":
     unittest.main()
 
diff --git a/tests/run-tests.py b/tests/run-tests.py
deleted file mode 100755
index d41aa0a..0000000
--- a/tests/run-tests.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/python
-# This is a dumb script to run tests on the sugar-jhbuild installed files
-# The path added is the default path for the jhbuild build
-
-INSTALL_PATH="../../../../../../install/lib/python2.5/site-packages/"
-
-import os, sys
-sys.path.insert(0,
-    os.path.abspath(INSTALL_PATH)
-)
-
-FULL_PATH = os.path.join(INSTALL_PATH,"sugar/tutorius")
-SUBDIRS = ["uam"]
-GLOB_PATH = os.path.join(FULL_PATH,"*.py")
-import unittest
-from glob import glob
-def report_files():
-    ret = glob(GLOB_PATH)
-    for dir in SUBDIRS:
-        ret += glob(os.path.join(FULL_PATH,dir,"*.py"))
-    return ret
-
-import sys
-if __name__=='__main__':
-    if "--coverage" in sys.argv:
-        sys.argv=[arg for arg in sys.argv if arg != "--coverage"]
-        import coverage
-        coverage.erase()
-        #coverage.exclude('raise NotImplementedError')
-        coverage.start()
-
-        import coretests
-        import servicestests
-        import gtkutilstests
-        #import overlaytests # broken
-        import linear_creatortests
-        import actiontests
-        import uamtests
-        import filterstests
-        import constraintstests
-        import propertiestests
-        import serializertests
-        suite = unittest.TestSuite()
-        suite.addTests(unittest.findTestCases(coretests))
-        suite.addTests(unittest.findTestCases(servicestests))
-        suite.addTests(unittest.findTestCases(gtkutilstests))
-        #suite.addTests(unittest.findTestCases(overlaytests)) # broken
-        suite.addTests(unittest.findTestCases(linear_creatortests))
-        suite.addTests(unittest.findTestCases(actiontests))
-        suite.addTests(unittest.findTestCases(uamtests))
-        suite.addTests(unittest.findTestCases(filterstests))
-        suite.addTests(unittest.findTestCases(constraintstests))
-        suite.addTests(unittest.findTestCases(propertiestests))
-        suite.addTests(unittest.findTestCases(serializertests))
-        runner = unittest.TextTestRunner()
-        runner.run(suite)
-        coverage.stop()
-        coverage.report(report_files())
-        coverage.erase()
-    else:
-        from coretests import *
-        from servicestests import *
-        from gtkutilstests import *
-        #from overlaytests import * # broken
-        from actiontests import *
-        from linear_creatortests import *
-        from uamtests import *
-        from filterstests import *
-        from constraintstests import *
-        from propertiestests import *
-        from actiontests import *
-        from serializertests import *
-
-        unittest.main()
diff --git a/tests/serializertests.py b/tests/serializertests.py
index c939b7a..2f2e287 100644
--- a/tests/serializertests.py
+++ b/tests/serializertests.py
@@ -164,7 +164,7 @@ class XMLSerializerTest(unittest.TestCase):
         self.test_save()
 
         reloaded_fsm = xml_ser.load_fsm(str(self.uuid))
-        assert self.fsm.is_identical(reloaded_fsm), "Expected equivalence before saving vs after loading."
+        assert self.fsm == reloaded_fsm, "Expected equivalence before saving vs after loading."
         
     def test_all_filters(self):
         """
@@ -190,7 +190,7 @@ class XMLSerializerTest(unittest.TestCase):
         
         reloaded_fsm = xml_ser.load_fsm(str(self.uuid))
 
-        assert self.fsm.is_identical(reloaded_fsm), "Expected equivalence before saving vs after loading."
+        assert self.fsm == reloaded_fsm, "Expected equivalence before saving vs after loading."
     
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/storetests.py b/tests/storetests.py
new file mode 100644
index 0000000..da20c00
--- /dev/null
+++ b/tests/storetests.py
@@ -0,0 +1,107 @@
+# Copyright (C) 2009, Tutorius.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+import unittest
+
+from sugar.tutorius.store import *
+
+g_tutorial_id = '114db454-b2a1-11de-8cfc-001f5bf747dc'
+g_other_id = '47efc6ee-b2a3-11de-8cfc-001f5bf747dc'
+
+class StoreProxyTest(unittest.TestCase):
+    def setUp(self):
+        self.store = StoreProxy()
+
+    def tearDown(self):
+        pass
+
+    def test_get_categories(self):
+        categories = self.store.get_categories()
+
+        assert isinstance(categories, list), "categories should be a list"
+
+    def test_get_tutorials(self):
+        self.store.get_tutorials()
+
+    def test_get_tutorial_collection(self):
+        collection_list = self.store.get_tutorial_collection('top5_rating')
+
+        assert isinstance(collection_list, list), "get_tutorial_collection should return a list"
+
+    def test_get_latest_version(self):
+        version_dict = self.store.get_latest_version([])
+
+        assert isinstance(version_dict, dict)
+
+    def test_download_tutorial(self):
+        tutorial = self.store.download_tutorial(g_tutorial_id)
+        
+        assert tutorial is not None
+
+    def test_login(self):
+        assert self.store.login("unknown_user", "random_password")
+
+    def test_register_new_user(self):
+        user_info = {
+            'name' : "Albert",
+            'last_name' : "The Tester",
+            'location' : 'Mozambique',
+            'email' : 'albertthetester@mozambique.org'
+        }
+        
+        assert self.store.register_new_user(user_info)
+            
+     
+class StoreProxyLoginTest(unittest.TestCase):
+    def setUp(self):
+        self.store = StoreProxy()
+        self.store.login("unknown_user", "random_password")
+
+    def tearDown(self):
+        session_id = self.store.get_session_id()
+
+        if session_id is not None:
+            self.store.close_session()
+    
+    def test_close_session(self):
+        assert self.store.close_session()
+
+    def test_get_session_id(self):
+        session_id = self.store.get_session_id()
+        
+        assert session_id is not None
+
+    def test_rate(self):
+        assert self.store.rate(5, g_tutorial_id)
+
+    def test_publish(self):
+        # TODO : We need to send in a real tutorial loaded from
+        # the Vault
+        assert self.store.publish(['This should be a real tutorial...'])
+
+    def test_unpublish(self):
+        # TODO : We need to send in a real tutorial loaded from
+        # the Vault
+        self.store.publish([g_tutorial_id, 'Fake tutorial'])
+
+        assert self.store.unpublish(g_tutorial_id)
+
+    def test_update_published_tutorial(self):
+        # TODO : Run these tests with files from the Vault
+        self.store.publish([g_tutorial_id, 'Fake tutorial'])
+
+        assert self.store.update_published_tutorial(g_tutorial_id, [g_tutorial_id, 'This is an updated tutorial']) 
+