Merge lp:~udt-contributors/mago/test-suite-class into lp:~mago-contributors/mago/mago-1.0

[Javier Collado]

[Javier Collado (javier.collado)]

Hello,

This is the branch with the changes to separate Applications from TesSuites.

As you will see, the code has been refactored a little and now there are two new subpackages called application and test_suite containing the code for the Application and TestSuite classes. Each package includes the following modules:
- main: Main definitions with code that applies to both gnome and ubuntu
- gnome: Definitions for gnome applications
- ubuntu: Definitions for ubuntu applications

In the main module in the test_suite package two classes are defined: TestSuite and SingleApplicationTestSuite. When using the latter, the application object is created and stored as self.application in the test suite object so in test cases code almost every reference to self.xxxx had to be changed to self.application. Aside from that, the code should be working the same way as before this change.

For test suites that need multiple applications to be tested at the same time, no class has been defined at the moment, but it should be straightforward once some requirements are defined.

Please let me know you comments/suggestions about this change.

Best regards,
   Javier

[Ara Pulido (ara)]

setup.py should be changed in order to make it work again:http://paste.ubuntu.com/159283/
Apart of that I think that change is needed, but it makes the framework complexity grow a bit.
The design document should explain this very carefully.

Besides, I am not sure if the folder structure is the correct one. desktop testing should contain the testsuite folder? what the rest of the udt-contributors think?

[Javier Collado (javier.collado)]

Hello,

The packages have been added to setup.py.

Regarding the growth of complexity, I agree that this is one of the consequences of the change, but in my opinion it's acceptable to avoid using applications and test suites as if they were the same thing since this is somewhat misleading.

The location of the test_suite folder makes sense to me because what I would do when writing a new test suite is importing something under desktoptesting.test_suite. However, this isn't necessarily the final location of the folder. If the team agrees, we might try things out this way and if someone comes up with a better organization, then we can upgrade. Fortunately, the project is still under development so I think we can afford to have changes in the framework and if they are not a good idea, we can discard them and continue looking for new ways to improve it.

Best regards,
    Javier

[lp:~udt-contributors/mago/test-suite-class]

67. By Eitan Isaacson on 2009-05-04

Changed screenshots to the following configuration:
- Compiz.
- 120 DPI.
- Default background.

68. By Eitan Isaacson on 2009-05-04

Merge from trunk.

69. By Eitan Isaacson on 2009-05-04

sensible fail message when python-indicate is not present.

70. By Eitan Isaacson on 2009-05-04

added a w second event loop to show_indicator(), seems to do a better job than simply processing pending events.

71. By Eitan Isaacson on 2009-05-04

added dx suites to setup.py

72. By Ara Pulido on 2009-05-05

Merged from tweaks

73. By Ara Pulido on 2009-05-06

Merged from test-suite-class. Resolved a small conflict

74. By Eitan Isaacson on 2009-05-06

moved enable_a11y to the Application class.

75. By Eitan Isaacson on 2009-05-06

Adjusted DX tests for the new layout.

=== added directory 'desktoptesting/application'
=== added file 'desktoptesting/application/__init__.py'
--- desktoptesting/application/__init__.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/application/__init__.py	2009-04-21 09:58:40 +0000
@@ -0,0 +1,6 @@
+"""
+applicatoin package
+
+Classes that wrap application functionality to ease their testing
+"""
+__all__ = ['main', 'gnome', 'ubuntu']

=== renamed file 'desktoptesting/gnome.py' => 'desktoptesting/application/gnome.py'
--- desktoptesting/gnome.py	2009-04-14 10:02:31 +0000
+++ desktoptesting/application/gnome.py	2009-04-21 09:58:40 +0000
@@ -3,158 +3,8 @@
 
 The gnome module provides wrappers for LDTP to make the write of Gnome tests easier. 
 """
-import ooldtp
-import ldtp 
-
-class Application:
-    """
-    Superclass for the rest of the applications
-
-    Constants that should be defined in the classes that inherit from this class
-    LAUNCHER: Argument to be passed when launching the application through ldtp.launchapp
-    WINDOW: Top application frame pattern using ldtp syntax
-    CLOSE_TYPE: Close object type (one of 'menu' or 'button')
-    CLOSE_NAME: Close object name
-    """
-    CLOSE_TYPE = 'menu'
-    CLOSE_NAME = 'mnuQuit'
-    WINDOW     = ''
-    TOP_PANEL = 'frmTopExpandedEdgePanel'
-
-
-    def __init__(self, name = None, close_type= None, close_name= None):
-        """
-        @type close_type: string
-        @param close_type: The type of close widget of the application. Types: menu, button.
-        @type close_name: string
-        @param close_name: The name of the close widget of the application. If not mentioned the default will be used ("Quit")
-        """
-        if name:
-            self.name = name
-        else:
-            self.name = self.WINDOW
-
-        if close_type:
-            self.close_type = close_type
-        else:
-            self.close_type = self.CLOSE_TYPE
-
-        if close_name:
-            self.close_name = close_name
-        else:
-            self.close_name = self.CLOSE_NAME
-
-
-    def setup(self):
-        pass
-
-    def teardown(self):
-        pass
-
-    def cleanup(self):
-        self.set_name(self.WINDOW)
-        self.set_close_type(self.CLOSE_TYPE)
-        self.set_close_name(self.CLOSE_NAME)
-
-    def recover(self):
-        self.teardown()
-        sleep(1)
-        self.setup()
-
-    def set_name(self, name):
-        if name is not None:
-            self.name = name
-
-    def set_close_type(self, close_type):
-        if close_type is not None:
-            self.close_type = close_type
-
-    def set_close_name(self, close_name):
-        if close_name is not None:
-            self.close_name = close_name
-
-    def remap(self):
-        """
-        It reloads the application map for the given ooldtp.context.
-        """
-        ldtp.remap(self.name)
-
-    def open(self):
-        """
-        Given an application, it tries to open it.
-         
-        """
-        ldtp.launchapp(self.LAUNCHER)
-
-        ldtp.wait(2)
-        response = ldtp.waittillguiexist(self.name, '', 20)
-        
-        if response == 0:
-            raise ldtp.LdtpExecutionError, "The " + self.name + " window was not found."    
-
-    def close(self):
-        """
-        Given an application, it tries to close it. 
-        """
-        try:
-            app = ooldtp.context(self.name)
-            try:
-                close_widget = app.getchild(self.close_name)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "The " + self.close_name + " widget was not found."
-
-            if self.close_type == 'menu':
-                close_widget.selectmenuitem()
-            elif self.close_type == 'button':
-                close_widget.click()
-            else:
-                raise ldtp.LdtpExecutionError, "Wrong close item type."
-            response = ldtp.waittillguinotexist(self.name, '', 20)
-            if response == 0:
-                raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application."
-        except ldtp.LdtpExecutionError, msg:
-            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application: " + str(msg)
-
-    def save(self, save_menu='mnuSave'):
-        """
-        Given an application, it tries to save the current document. 
-        This method gives very basic functionality. Please, override this method in the subclasses for error checking.
-         
-        @type save_menu: string
-        @param save_menu: The name of the Save menu of the application. If not mentioned the default will be used ("Save").
-        """
-        try:
-            app = ooldtp.context(self.name)
-            try:
-                actualMenu = app.getchild(save_menu)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "The " + save_menu + " menu was not found."
-
-            actualMenu.selectmenuitem()
-        except ldtp.LdtpExecutionError:
-            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when saving the current document."
-
-    def write_text(self, text, txt_field=''):
-        """
-        Given an application it tries to write text to its current buffer.
-        """
-        app = ooldtp.context(self.name)
-
-        if txt_field == '':
-            try:
-                ldtp.enterstring(text)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "We couldn't write text."
-        else:
-            try:
-                app_txt_field = app.getchild(txt_field)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "The " + txt_field + " text field was not found."
-            try:
-                app_txt_field.settextvalue(text)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "We couldn't write text."
-
+import ldtp, ooldtp
+from .main import Application
 
 class Seahorse(Application):
     """
@@ -187,19 +37,10 @@
     TAB_PERSONAL_KEYS   = "My Personal Keys"
     TAB_LIST            = "ptl0"
 
+
     def __init__(self):
         Application.__init__(self)
 
-    def setup(self):
-        self.open()
-
-    def teardown(self):
-        self.close()
-
-    def cleanup(self):
-        #TODO: it should delete all the "My Personal Keys"
-        pass
-
 
     def new_key(self, key_type):
         """
@@ -528,44 +369,6 @@
     def __init__(self):
         Application.__init__(self)
 
-    def setup(self):
-        self.open()
-
-    def teardown(self):
-        self.close()
-
-    def cleanup(self):
-        # Exit using the Quit menu 
-        try:
-            try:
-                gedit = ooldtp.context(self.name)
-                quit_menu = gedit.getchild(self.MNU_CLOSE)
-            except ldtp.LdtpExecutionError:
-                raise ldtp.LdtpExecutionError, "The quit menu was not found."
-            quit_menu.selectmenuitem()
-        except ldtp.LdtpExecutionError:
-            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application."
-
-        result = ldtp.waittillguiexist(self.QUESTION_DLG,
-                                       guiTimeOut = 2)
-
-        if result == 1:
-            question_dialog = ooldtp.context(self.QUESTION_DLG)
-            question_dlg_btn_close = question_dialog.getchild(self.QUESTION_DLG_BTN_CLOSE)
-            question_dlg_btn_close.click()
-        
-        try:
-            gedit = ooldtp.context(self.name)
-            new_menu = gedit.getchild(self.MNU_NEW)
-        except ldtp.LdtpExecutionError:
-            raise ldtp.LdtpExecutionError, "The new menu was not found."
-        new_menu.selectmenuitem()
-        
-        result = ldtp.waittillguiexist(
-            self.name, self.TXT_FIELD)
-        if result != 1:
-            raise ldtp.LdtpExecutionError, "Failed to set up new document."
-        
 
     def write_text(self, text):
         """
@@ -760,7 +563,3 @@
           
         cancelButton.click()
         ldtp.waittillguinotexist (self.name)
-        
-
-        
-    

=== added file 'desktoptesting/application/main.py'
--- desktoptesting/application/main.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/application/main.py	2009-04-21 09:58:40 +0000
@@ -0,0 +1,138 @@
+"""
+main module contains the definition of the main Application class
+that is used to wrap applications functionality
+"""
+import ldtp, ooldtp
+
+class Application:
+    """
+    Superclass for the rest of the applications
+
+    Constants that should be defined in the classes that inherit from this class
+    LAUNCHER: Argument to be passed when launching the application through ldtp.launchapp
+    WINDOW: Top application frame pattern using ldtp syntax
+    CLOSE_TYPE: Close object type (one of 'menu' or 'button')
+    CLOSE_NAME: Close object name
+    """
+    CLOSE_TYPE = 'menu'
+    CLOSE_NAME = 'mnuQuit'
+    WINDOW     = ''
+    TOP_PANEL = 'frmTopExpandedEdgePanel'
+
+
+    def __init__(self, name = None, close_type= None, close_name= None):
+        """
+        @type close_type: string
+        @param close_type: The type of close widget of the application. Types: menu, button.
+        @type close_name: string
+        @param close_name: The name of the close widget of the application. If not mentioned the default will be used ("Quit")
+        """
+        if name:
+            self.name = name
+        else:
+            self.name = self.WINDOW
+
+        if close_type:
+            self.close_type = close_type
+        else:
+            self.close_type = self.CLOSE_TYPE
+
+        if close_name:
+            self.close_name = close_name
+        else:
+            self.close_name = self.CLOSE_NAME
+
+
+    def set_name(self, name):
+        if name is not None:
+            self.name = name
+
+    def set_close_type(self, close_type):
+        if close_type is not None:
+            self.close_type = close_type
+
+    def set_close_name(self, close_name):
+        if close_name is not None:
+            self.close_name = close_name
+
+    def remap(self):
+        """
+        It reloads the application map for the given ooldtp.context.
+        """
+        ldtp.remap(self.name)
+
+    def open(self):
+        """
+        Given an application, it tries to open it.
+         
+        """
+        ldtp.launchapp(self.LAUNCHER)
+
+        ldtp.wait(2)
+        response = ldtp.waittillguiexist(self.name, '', 20)
+        
+        if response == 0:
+            raise ldtp.LdtpExecutionError, "The " + self.name + " window was not found."    
+
+    def close(self):
+        """
+        Given an application, it tries to close it. 
+        """
+        try:
+            app = ooldtp.context(self.name)
+            try:
+                close_widget = app.getchild(self.close_name)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "The " + self.close_name + " widget was not found."
+
+            if self.close_type == 'menu':
+                close_widget.selectmenuitem()
+            elif self.close_type == 'button':
+                close_widget.click()
+            else:
+                raise ldtp.LdtpExecutionError, "Wrong close item type."
+            response = ldtp.waittillguinotexist(self.name, '', 20)
+            if response == 0:
+                raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application."
+        except ldtp.LdtpExecutionError, msg:
+            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application: " + str(msg)
+
+    def save(self, save_menu='mnuSave'):
+        """
+        Given an application, it tries to save the current document. 
+        This method gives very basic functionality. Please, override this method in the subclasses for error checking.
+         
+        @type save_menu: string
+        @param save_menu: The name of the Save menu of the application. If not mentioned the default will be used ("Save").
+        """
+        try:
+            app = ooldtp.context(self.name)
+            try:
+                actualMenu = app.getchild(save_menu)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "The " + save_menu + " menu was not found."
+
+            actualMenu.selectmenuitem()
+        except ldtp.LdtpExecutionError:
+            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when saving the current document."
+
+    def write_text(self, text, txt_field=''):
+        """
+        Given an application it tries to write text to its current buffer.
+        """
+        app = ooldtp.context(self.name)
+
+        if txt_field == '':
+            try:
+                ldtp.enterstring(text)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "We couldn't write text."
+        else:
+            try:
+                app_txt_field = app.getchild(txt_field)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "The " + txt_field + " text field was not found."
+            try:
+                app_txt_field.settextvalue(text)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "We couldn't write text."

=== renamed file 'desktoptesting/ubuntu.py' => 'desktoptesting/application/ubuntu.py'
--- desktoptesting/ubuntu.py	2009-04-14 10:02:31 +0000
+++ desktoptesting/application/ubuntu.py	2009-04-21 09:58:40 +0000
@@ -3,23 +3,13 @@
 
 The ubuntu module provides wrappers for LDTP to make the write of Ubuntu tests easier. 
 """
-import ooldtp 
-import ldtp 
-from desktoptesting.gnome import Application, PolicyKit
+import ldtp , ooldtp
 import re
 
+from .main import Application
+from .gnome import PolicyKit
+
 class UbuntuMenu(Application):
-    
-    def setup(self):
-        pass
-
-    def teardown(self):
-        self.cleanup() 
-
-    def cleanup(self):
-        self.close()
-        Application.cleanup(self)
-
     def open_and_check_menu_item(self, menu_item_txt):
         """
         Given a menu item, it tries to open the application associated with it.

=== added directory 'desktoptesting/test_suite'
=== added file 'desktoptesting/test_suite/__init__.py'
--- desktoptesting/test_suite/__init__.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/test_suite/__init__.py	2009-04-21 09:58:40 +0000
@@ -0,0 +1,6 @@
+"""
+test_suite package
+
+Test suite classes that implement setup/teardown/cleanup methods
+"""
+__all__ = ['main', 'gnome', 'ubuntu']

=== added file 'desktoptesting/test_suite/gnome.py'
--- desktoptesting/test_suite/gnome.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/test_suite/gnome.py	2009-04-21 10:15:09 +0000
@@ -0,0 +1,70 @@
+"""
+gnome module contains the definition of the test suites used for gnome
+applications
+"""
+import ldtp, ooldtp
+from .main import SingleApplicationTestSuite
+from ..application.gnome import Application, Seahorse, GEdit
+
+class SeahorseTestSuite(SingleApplicationTestSuite):
+    """
+    Default test suite for Seahorse
+    """
+    def __init__(self):
+        SingleApplicationTestSuite.__init__(self, Seahorse)
+
+    def setup(self):
+        self.application.open()
+
+    def teardown(self):
+        self.application.close()
+
+    def cleanup(self):
+        #TODO: it should delete all the "My Personal Keys"
+        pass
+
+
+class GEditTestSuite(SingleApplicationTestSuite):
+    """
+    Default test suite for GEdit
+    """
+    def __init__(self):
+        SingleApplicationTestSuite.__init__(self, GEdit)
+
+    def setup(self):
+        self.application.open()
+
+    def teardown(self):
+        self.application.close()
+
+    def cleanup(self):
+        # Exit using the Quit menu 
+        try:
+            try:
+                gedit = ooldtp.context(self.application.name)
+                quit_menu = gedit.getchild(self.application.MNU_CLOSE)
+            except ldtp.LdtpExecutionError:
+                raise ldtp.LdtpExecutionError, "The quit menu was not found."
+            quit_menu.selectmenuitem()
+        except ldtp.LdtpExecutionError:
+            raise ldtp.LdtpExecutionError, "Mmm, something went wrong when closing the application."
+
+        result = ldtp.waittillguiexist(self.application.QUESTION_DLG,
+                                       guiTimeOut = 2)
+
+        if result == 1:
+            question_dialog = ooldtp.context(self.application.QUESTION_DLG)
+            question_dlg_btn_close = question_dialog.getchild(self.application.QUESTION_DLG_BTN_CLOSE)
+            question_dlg_btn_close.click()
+        
+        try:
+            gedit = ooldtp.context(self.application.name)
+            new_menu = gedit.getchild(self.application.MNU_NEW)
+        except ldtp.LdtpExecutionError:
+            raise ldtp.LdtpExecutionError, "The new menu was not found."
+        new_menu.selectmenuitem()
+
+        result = ldtp.waittillguiexist(
+            self.application.name, self.application.TXT_FIELD)
+        if result != 1:
+            raise ldtp.LdtpExecutionError, "Failed to set up new document."

=== added file 'desktoptesting/test_suite/main.py'
--- desktoptesting/test_suite/main.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/test_suite/main.py	2009-04-21 10:15:09 +0000
@@ -0,0 +1,31 @@
+"""
+test_suite module contains the definition of the TestSuite class that
+must be used by all test suites written for the desktoptesting package
+"""
+class TestSuite:
+    """
+    TestSuite that implements all the test suite methods desired in a
+    test suite
+    """
+    def setup(self):
+        pass
+
+    def teardown(self):
+        pass
+
+    def cleanup(self):
+        pass
+
+
+class SingleApplicationTestSuite(TestSuite):
+    """
+    Test suite intended to make sure that a single application is
+    running
+    """
+    def __init__(self, application_factory):
+        self.application = application_factory()
+
+    def cleanup(self):
+        self.application.set_name(self.application.WINDOW)
+        self.application.set_close_type(self.application.CLOSE_TYPE)
+        self.application.set_close_name(self.application.CLOSE_NAME)

=== added file 'desktoptesting/test_suite/ubuntu.py'
--- desktoptesting/test_suite/ubuntu.py	1970-01-01 00:00:00 +0000
+++ desktoptesting/test_suite/ubuntu.py	2009-04-21 09:58:40 +0000
@@ -0,0 +1,22 @@
+"""
+ubuntu module contains the definition of the test suites used for ubuntu
+applications
+"""
+from .main import SingleApplicationTestSuite
+from ..application.ubuntu import UbuntuMenu, UpdateManager
+
+class UbuntuMenuTestSuite(SingleApplicationTestSuite):
+    def __init__(self):
+        SingleApplicationTestSuite.__init__(self, UbuntuMenu)
+
+    def teardown(self):
+        self.cleanup() 
+
+    def cleanup(self):
+        self.application.close()
+        SingleApplicationTestSuite.cleanup(self)
+
+
+class UpdateManagerTestSuite(SingleApplicationTestSuite):
+    def __init__(self):
+        SingleApplicationTestSuite.__init__(self, UpdateManager)

=== modified file 'gedit/gedit_chains.py'
--- gedit/gedit_chains.py	2009-03-11 16:35:00 +0000
+++ gedit/gedit_chains.py	2009-04-21 10:15:09 +0000
@@ -1,20 +1,16 @@
 # -*- coding: utf-8 -*-
-
-import ldtp
-import ldtputils
-
 from time import time, gmtime, strftime
 
-from desktoptesting.gnome import GEdit
+from desktoptesting.test_suite.gnome import GEditTestSuite
 from desktoptesting.check import FileComparison, FAIL
 
-class GEditChain(GEdit):
+class GEditChain(GEditTestSuite):
     def testChain(self, oracle=None, chain=None):
         test_file = strftime(
             "/tmp/" + "%Y%m%d_%H%M%S" + ".txt", gmtime((time())))
 
-        self.write_text(chain)
-        self.save(test_file)
+        self.application.write_text(chain)
+        self.application.save(test_file)
 
         testcheck = FileComparison(oracle, test_file)
 

=== modified file 'seahorse/generate_pgp.py'
--- seahorse/generate_pgp.py	2009-03-19 10:47:43 +0000
+++ seahorse/generate_pgp.py	2009-04-21 10:15:09 +0000
@@ -1,18 +1,9 @@
-import ldtp 
-import ldtputils 
-from time import time 
-
-from desktoptesting.gnome import Seahorse
-
+from desktoptesting.test_suite.gnome import SeahorseTestSuite
     
-class SeahorsePGP(Seahorse):
+class SeahorsePGP(SeahorseTestSuite):
     def test_generate_pgp(self, name, email, comment, passphrase):
-        
         # Open the update manager and check the repositories
-        self.new_pgp_key(name, email, comment, passphrase)
+        self.application.new_pgp_key(name, email, comment, passphrase)
 
-        if self.assert_exists_key(name) == False:
+        if self.application.assert_exists_key(name) == False:
             raise AssertionError, "The key was not succesfully created."
-
-
-

=== modified file 'seahorse/generate_ssh.py'
--- seahorse/generate_ssh.py	2009-03-18 16:15:59 +0000
+++ seahorse/generate_ssh.py	2009-04-21 10:15:09 +0000
@@ -1,15 +1,10 @@
-import ldtp 
-import ldtputils 
-from time import time 
-
-from desktoptesting.gnome import Seahorse
-
-class SeahorseSSH(Seahorse):
+from desktoptesting.test_suite.gnome import SeahorseTestSuite
+
+class SeahorseSSH(SeahorseTestSuite):
     def test_generate_ssh(self, description, set_up, passphrase, computer='', login=''):
         # Create the new key
-        self.new_ssh_key(description, set_up, passphrase, computer, login)
+        self.application.new_ssh_key(description, set_up, passphrase, computer, login)
 
         # Check that the key was successfully created
-        if self.assert_exists_key(description) == False:
+        if self.application.assert_exists_key(description) == False:
             raise AssertionError, "The key was not succesfully created."
-

=== modified file 'ubuntu-menu/ubuntu_menu.py'
--- ubuntu-menu/ubuntu_menu.py	2009-03-23 10:53:02 +0000
+++ ubuntu-menu/ubuntu_menu.py	2009-04-21 10:15:09 +0000
@@ -1,19 +1,13 @@
-import ldtp 
-import ldtputils
-from time import time 
-
-from desktoptesting.ubuntu import UbuntuMenu
-
-class UbuntuMenuTest(UbuntuMenu):
+from desktoptesting.test_suite.ubuntu import UbuntuMenuTestSuite
+
+class UbuntuMenuTest(UbuntuMenuTestSuite):
        
     def testOpenMenu(self, menuitem=None, windowname=None, closetype=None, closename=None):
-        self.set_name(windowname)
-        self.set_close_type(closetype)
-        self.set_close_name(closename)
-        self.open_and_check_menu_item(menuitem)
+        self.application.set_name(windowname)
+        self.application.set_close_type(closetype)
+        self.application.set_close_name(closename)
+        self.application.open_and_check_menu_item(menuitem)
         
 if __name__ == "__main__":
     ubuntu_menu_test = UbuntuMenuTest()
     ubuntu_menu_test.run()
-
-

=== modified file 'update-manager/update_manager.py'
--- update-manager/update_manager.py	2009-03-25 10:11:44 +0000
+++ update-manager/update_manager.py	2009-04-21 10:15:09 +0000
@@ -1,26 +1,22 @@
-import ldtp
-import ldtputils
-
-from desktoptesting.ubuntu import UpdateManager
-
-class UpdateManagerTest(UpdateManager):
+from desktoptesting.test_suite.ubuntu import UpdateManagerTestSuite
+
+class UpdateManagerTest(UpdateManagerTestSuite):
     def test_update_first(self, password):
-
-        self.set_password(password)
-
-        self.check_updates()
-        list = self.get_available_updates()
+        self.application.set_password(password)
+
+        self.application.check_updates()
+        list = self.application.get_available_updates()
 
         # If there is any update, select the first one
         if len(list) > 0:
             name = list[0]
-            self.unselect_all()
-            self.tick_update(name)
-            self.install_updates()
+            self.application.unselect_all()
+            self.application.tick_update(name)
+            self.application.install_updates()
      
         
         # Check again the list of updates
-        list = self.get_available_updates()
+        list = self.application.get_available_updates()
 
         # If the updated package is still in the list of 
         # updates, the mark the test as failed.
@@ -29,14 +25,14 @@
 
     def test_update_none(self, password):
 
-        self.set_password(password)
+        self.application.set_password(password)
 
         # Open the update manager and check the repositories
-        self.check_updates()
-        n_updates = self.number_updates()
+        self.application.check_updates()
+        n_updates = self.application.number_updates()
 
-        self.check_updates()
-        n_updates2 = self.number_updates()
+        self.application.check_updates()
+        n_updates2 = self.application.number_updates()
 
 
         # If the number of updates differ, the mark the test as failed.
@@ -45,13 +41,13 @@
 
     def test_unselect_all(self):
 
-        size = self.download_size()
+        size = self.application.download_size()
 
         if size > 0:
-            self.unselect_all()
-            self.remap()
+            self.application.unselect_all()
+            self.application.remap()
 
-            size = self.download_size()
+            size = self.application.download_size()
             
             # Test size
             if size > 0:
@@ -63,11 +59,11 @@
      
     def test_install_updates(self, password):
     
-        self.check_updates()
-        self.install_updates()
+        self.application.check_updates()
+        self.application.install_updates()
 
-        self.remap()
-        n_updates = self.number_updates()
+        self.application.remap()
+        n_updates = self.application.number_updates()
         
         if n_updates > 0:
             raise AssertionError, 'Not all the updates were installed.'