# Copyright (C) 2009, Tutorius.org # Copyright (C) 2009, Jean-Christophe Savard # # 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 """ Serialization Tests This module contains all the tests that pertain to the usage of the Tutorius Serializer object. This means testing saving a tutorial dictionary to a .tml file, loading the list of tutorials for this activity and building chosen tutorial. """ import unittest import logging import linecache import os import shutil from sugar.tutorius import gtkutils, overlayer from sugar.tutorius.core import Tutorial, State, FiniteStateMachine from sugar.tutorius.actions import DialogMessage, OnceWrapper, BubbleMessage from sugar.tutorius.filters import GtkWidgetEventFilter, TimerEvent from sugar.tutorius.bundler import * from uuid import * import rpdb2 class XMLSerializerTest(unittest.TestCase): """ Tests the transformation of XML to FSM, then back. """ def setUp(self): # Create the sample FSM self.fsm = FiniteStateMachine("testingMachine") # Add a few states act1 = BubbleMessage(message="Hi", pos=[300, 450]) ev1 = GtkWidgetEventFilter("0.12.31.2.2", "clicked", "Second") act2 = BubbleMessage(message="Second message", pos=[250, 150], tailpos=[1,2]) st1 = State("INIT") st1.add_action(act1) st2 = State("Second") st2.add_action(act2) self.fsm.add_state(st1) self.fsm.add_state(st2) self.uuid = uuid1() def test_save(self, remove=True): """ Writes an FSM to disk, then compares the file to the expected results. "Remove" boolean argument specify if the test data must be removed or not """ # Make the serializer believe the test is in a activity path testpath = "/tmp/testdata/" os.environ["SUGAR_BUNDLE_PATH"] = testpath os.environ["SUGAR_PREFIX"] = testpath ## os.mkdir(sugar.tutorius.bundler._get_store_root()) xml_ser = XMLSerializer() os.makedirs(os.path.join(sugar.tutorius.bundler._get_store_root(), str(self.uuid))) #rpdb2.start_embedded_debugger('flakyPass') xml_ser.save_fsm(self.fsm, "fsm.xml", os.path.join(sugar.tutorius.bundler._get_store_root(), str(self.uuid))) #Remove test file and path if remove == True: os.remove(os.path.join(sugar.tutorius.bundler._get_store_root(), str(self.uuid)) + "/fsm.xml") if os.path.isdir(testpath): shutil.rmtree(testpath) def test_save_and_load(self): """ Load up the written FSM and compare it with the object representation. """ self.test_save(False) testpath = "/tmp/testdata/" #rpdb2.start_embedded_debugger('flakyPass') xml_ser = XMLSerializer() # This interface needs to be redone... It's not clean because there is # a responsibility mixup between the XML reader and the bundler. loaded_fsm = xml_ser.load_fsm(str(self.uuid)) # Compare the two FSMs assert loaded_fsm._states.get("INIT").name == self.fsm._states.get("INIT").name, \ 'FSM underlying dictionary differ from original to pickled/reformed one' assert loaded_fsm._states.get("Second").name == self.fsm._states.get("Second").name, \ 'FSM underlying dictionary differ from original to pickled/reformed one' assert loaded_fsm._states.get("INIT").get_action_list()[0].get_message() == \ self.fsm._states.get("INIT").get_action_list()[0].get_message(), \ 'FSM underlying State underlying Action differ from original to reformed one' os.remove(os.path.join(sugar.tutorius.bundler._get_store_root(), str(self.uuid)) + "/fsm.xml") if os.path.isdir(testpath): shutil.rmtree(testpath) # Helper classes to help testing class SerializerTest(unittest.TestCase): """ This class has to test the Serializer methods as well as the expected functionality. """ # Voiding test as it is meant to be used with the pickle serializer, # that was deprecated ## def test_pickle_integrity(self): ## """ ## Validates content is uncorrupted trough a pickle file save/load. ## """ ## ## # Sample valid FSM dict ## sampleDict = { ## "INIT":State("INIT", ## action_list=[ ## OnceWrapper(BubbleMessage(message="Welcome to the text editor tutorial!\n\n Click on the canvas and type a letter.", pos=[100,100], tailpos=[-10,-20])), ## ], ## event_filter_list=[ ## GtkWidgetEventFilter("TEXT","0.0.0.1.0.0.0","key-press-event"), ## TimerEvent("LOST",15), ## ], ## ), ## "LOST":State("LOST", ## action_list=[BubbleMessage("Click in the canvas and type on your keyboard", [400, 400]),], ## event_filter_list=[ ## GtkWidgetEventFilter("TEXT","0.0.0.1.0.0.0","key-press-event"), ## TimerEvent("INIT",5), ## ], ## ), ## "TEXT":State("TEXT", ## action_list=[OnceWrapper(BubbleMessage(" You can type more letters if you want!\n\n" + ## "To proceed to the next step, select your text.\n\n Click and drag over the text!", [200,150])),], ## event_filter_list=[ ## GtkWidgetEventFilter("SELECTED","0.0.0.1.0.0","text-selected"), ## ], ## ), ## } ## ## testpath = "/tmp/testdata/" ## ## # Create testdata/ folder if no exists ## if not os.path.exists(testpath): ## os.mkdir(testpath) ## ## serialize = TutoSerializer() ## ## # Make the class believe the test is in a activity path ## os.environ["SUGAR_ACTIVITY_ROOT"] = testpath ## ## fsm = FiniteStateMachine("Test", state_dict=sampleDict) ## ## serialize.save_tutorial("Test", "Test", fsm, "serializeTest") ## ## fileDict = serialize.load_tuto_list() ## ## for filekey, tutorial in fileDict.items(): ## if filekey == "Test": ## reformedTuto = serialize.build_tutorial(filekey) ## ## reformedfsm = reformedTuto.get("Test").state_machine ## ## #Tests ## assert reformedfsm._states.get("INIT").name == fsm._states.get("INIT").name, \ ## 'FSM underlying dictionary differ from original to pickled/reformed one' ## assert reformedfsm._states.get("LOST").name == fsm._states.get("LOST").name, \ ## 'FSM underlying dictionary differ from original to pickled/reformed one' ## assert reformedfsm._states.get("TEXT").name == fsm._states.get("TEXT").name, \ ## 'FSM underlying dictionary differ from original to pickled/reformed one' ## ## ## os.remove(testpath + "serializeTest.tml") ## os.rmdir(testpath) ## os.rmdir("/tmp") if __name__ == "__main__": unittest.main()