ut: make pyanaconda_test/backed_test.py pass

Some of those tests are not entirely useful but at least they shouldn't
fail the suite.

Also removes trailing whitespace from baseudev_test.py and desktop_test.py.

3 files changed, 128 insertions, 141 deletions

diff --git a/tests/pyanaconda_test/backend_test.py b/tests/pyanaconda_test/backend_test.py
index 3f932b8ef..ee888dfed 100644
--- a/tests/pyanaconda_test/backend_test.py
+++ b/tests/pyanaconda_test/backend_test.py
@@ -3,45 +3,46 @@
 import mock
 
 class BackendTest(mock.TestCase):
-    
+
     def setUp(self):
         import pykickstart.commands
-    
-        self.setupModules(["_isys", "block", 'parted', 'storage', 
-                    'pyanaconda.storage.formats', 'logging', 'pykickstart',
-                    'ConfigParser', 'pyanaconda.anaconda_log', 
+
+        self.setupModules(["_isys", "block", 'parted', 'storage',
+                    'pyanaconda.storage.formats', 'logging',
+                    'ConfigParser', 'pyanaconda.anaconda_log',
                     'pyanaconda.storage.storage_log'])
-        self.fs = mock.DiskIO()
-        
-        import sys
-        sys.modules['pykickstart.version'] = mock.Mock()
-        sys.modules['pykickstart.version'].returnClassForVersion = mock.Mock()
-        
+
         import pyanaconda
         pyanaconda.anaconda_log = mock.Mock()
-               
+
+        import logging
+        self.logger = mock.Mock()
+        logging.getLogger.return_value = self.logger
+
         self.DD_EXTRACTED = '/tmp/DD'
-        
+
         import pyanaconda.backend
         pyanaconda.backend.os = mock.Mock()
         pyanaconda.backend.DD_EXTRACTED = self.DD_EXTRACTED
         pyanaconda.backend.glob = mock.Mock()
         pyanaconda.backend.shutil = mock.Mock()
-          
+
+        self.logger.reset_mock()
+
     def tearDown(self):
         self.tearDownModules()
-    
+
     def anaconda_backend_copy_firmware_test(self):
         import pyanaconda.backend
         FILE = 'foo'
         pyanaconda.backend.glob.glob.return_value = [FILE]
-        
+
         anaconda = mock.Mock()
         anaconda.rootPath = ''
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
         ab.copyFirmware(anaconda)
         self.assertEqual(pyanaconda.backend.shutil.copyfile.call_args[0][0], FILE)
-    
+
     def anaconda_backend_do_post_install_test(self):
         import pyanaconda.backend
         FILE = 'foo'
@@ -53,41 +54,41 @@ class BackendTest(mock.TestCase):
             return_value=[(A, B, C)])
         pyanaconda.backend.packages = mock.Mock()
         pyanaconda.backend.glob.glob.return_value = [FILE]
-        
+
         pyanaconda.backend.os.path.exists.return_value=True
         pyanaconda.backend.os.path.basename.return_value=""
-        
+
         pyanaconda.backend.storage = mock.Mock()
         pyanaconda.backend.sys = mock.Mock()
-        
+
         anaconda = mock.Mock()
         anaconda.rootPath = ''
         anaconda.extraModules = True
-        
+
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
         ab.doPostInstall(anaconda)
-        
-        self.assertEqual(pyanaconda.backend.packages.method_calls[0], 
+
+        self.assertEqual(pyanaconda.backend.packages.method_calls[0],
             ('recreateInitrd', (A, ''), {}))
-        self.assertEqual(pyanaconda.backend.shutil.method_calls[0], 
+        self.assertEqual(pyanaconda.backend.shutil.method_calls[0],
             ('copytree', (FILE, '/root/'), {}))
         self.assertEqual(pyanaconda.backend.shutil.method_calls[1],
             ('copytree', (self.DD_EXTRACTED, '/root/DD'), {}))
         self.assertTrue(pyanaconda.backend.storage.writeEscrowPackets.called)
-    
+
     def anaconda_backend_do_install_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
         self.assertRaises(NotImplementedError, ab.doInstall, anaconda)
-       
+
     def anaconda_backend_kernel_version_list_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
         ret = ab.kernelVersionList()
         self.assertEqual([], ret)
-    
+
     def anaconda_backend_get_minimum_size_mb_test(self):
         import pyanaconda.backend
         PART = mock.Mock()
@@ -95,83 +96,84 @@ class BackendTest(mock.TestCase):
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
         ret = ab.getMinimumSizeMB(PART)
         self.assertEqual(0, ret)
-    
+
     def anaconda_backend_do_backend_setup_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.doBackendSetup, anaconda)
-    
+        ab.doBackendSetup(anaconda)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_group_exists_test(self):
         import pyanaconda.backend
         GROUP = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.groupExists, GROUP)
-    
+        ab.groupExists(GROUP)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_select_group_test(self):
         import pyanaconda.backend
         GROUP = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.selectGroup, GROUP)
-    
+        ab.selectGroup(GROUP)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_deselect_group_test(self):
         import pyanaconda.backend
         GROUP = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.deselectGroup, GROUP)
-    
+        ab.deselectGroup(GROUP)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_package_exists_test(self):
         import pyanaconda.backend
         PKG = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.packageExists, PKG)
-    
+        ab.packageExists(PKG)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_select_package_test(self):
         import pyanaconda.backend
         PKG = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.selectPackage, PKG)
-    
+        ab.selectPackage(PKG)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_deselect_package_test(self):
         import pyanaconda.backend
         PKG = mock.Mock()
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.deselectPackage, PKG)
-    
+        ab.deselectPackage(PKG)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_get_default_groups_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.getDefaultGroups, anaconda)
-    
-    #def anaconda_backend_reset_package_selections_test(self):
-    #    pass
-    
+        ab.getDefaultGroups(anaconda)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_write_packages_ks_test(self):
         import pyanaconda.backend
         FILE = ''
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.writePackagesKS, FILE, anaconda)
-    
+        ab.writePackagesKS(FILE, anaconda)
+        self.assertTrue(self.logger.warning.called)
+
     def anaconda_backend_write_configuration_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        self.assertRaises(NotImplementedError, ab.writeConfiguration)
-    
-    #def anaconda_backend_write_ks_test(self):
-    #    pass
-    
-    #def anaconda_backend_complete_test(self):
-    #    pass
-    
+        ab.writeConfiguration()
+        self.assertTrue(self.logger.warning.called)
+
     def do_backend_setup_1_test(self):
         import pyanaconda.backend
         RET = -1
@@ -180,68 +182,54 @@ class BackendTest(mock.TestCase):
         anaconda.backend.doBackendSetup.return_value = RET
         ret = pyanaconda.backend.doBackendSetup(anaconda)
         self.assertEqual(RET, ret)
-        
-    def do_backend_setup_2_test(self):
-        import pyanaconda.backend
-        pyanaconda.backend.iutil = mock.Mock()
-        
-        RET = -1
-        pyanaconda.backend.DISPATCH_BACK = RET
-        anaconda = mock.Mock()
-        anaconda.backend.doBackendSetup.return_value = RET + 5
-        anaconda.upgrade = True
-        
-        pyanaconda.backend.doBackendSetup(anaconda)
-        self.assertTrue(pyanaconda.backend.iutil.writeRpmPlatform.called)
-    
+
     def do_post_selection_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         pyanaconda.backend.doPostSelection(anaconda)
         self.assertTrue(anaconda.backend.doPostSelection.called)
-    
+
     def do_pre_install_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         pyanaconda.backend.doPreInstall(anaconda)
         self.assertTrue(anaconda.backend.doPreInstall.called)
-    
+
     def do_post_install_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         pyanaconda.backend.doPostInstall(anaconda)
         self.assertTrue(anaconda.backend.doPostInstall.called)
-    
+
     def do_install_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         pyanaconda.backend.doInstall(anaconda)
         self.assertTrue(anaconda.backend.doInstall.called)
-    
+
     def do_base_package_select_1_test(self):
         import pyanaconda.backend
         pyanaconda.backend.kickstart = mock.Mock()
         anaconda = mock.Mock()
         anaconda.ksdata = True
-        
+
         pyanaconda.backend.doBasePackageSelect(anaconda)
         self.assertTrue(anaconda.backend.resetPackageSelections.called)
         self.assertTrue(pyanaconda.backend.kickstart.selectPackages.called)
-    
+
     def do_base_package_select_2_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         anaconda.ksdata = False
-        
+
         pyanaconda.backend.doBasePackageSelect(anaconda)
         self.assertTrue(anaconda.backend.resetPackageSelections.called)
         self.assertTrue(anaconda.instClass.setPackageSelection.called)
         self.assertTrue(anaconda.instClass.setGroupSelection.called)
-    
+
     def write_configuration_test(self):
         import pyanaconda.backend
         anaconda = mock.Mock()
         pyanaconda.backend.writeConfiguration(anaconda)
         self.assertTrue(anaconda.write.called)
         self.assertTrue(anaconda.backend.writeConfiguration)
-    
diff --git a/tests/pyanaconda_test/baseudev_test.py b/tests/pyanaconda_test/baseudev_test.py
index cd49fa8bd..4dd422b88 100644
--- a/tests/pyanaconda_test/baseudev_test.py
+++ b/tests/pyanaconda_test/baseudev_test.py
@@ -4,70 +4,70 @@ import mock
 import os
 
 class BaseudevTest(mock.TestCase):
-    
+
     def setUp(self):
         self.setupModules(["_isys", "block", "ConfigParser"])
         self.fs = mock.DiskIO()
-        
+
         import pyanaconda.baseudev
         pyanaconda.baseudev.os = mock.Mock()
         pyanaconda.baseudev.log = mock.Mock()
         pyanaconda.baseudev.open = self.fs.open
-        
+
     def tearDown(self):
         self.tearDownModules()
-        
+
     def udev_enumerate_devices_test(self):
-        import pyanaconda.baseudev      
+        import pyanaconda.baseudev
         ENUMERATE_LIST = [
-            '/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda', 
-            '/sys/devices/virtual/block/loop0', 
-            '/sys/devices/virtual/block/loop1', 
-            '/sys/devices/virtual/block/ram0', 
-            '/sys/devices/virtual/block/ram1', 
+            '/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
+            '/sys/devices/virtual/block/loop0',
+            '/sys/devices/virtual/block/loop1',
+            '/sys/devices/virtual/block/ram0',
+            '/sys/devices/virtual/block/ram1',
             '/sys/devices/virtual/block/dm-0',
         ]
-        
+
         pyanaconda.baseudev.global_udev.enumerate_devices = mock.Mock(return_value=ENUMERATE_LIST)
         ret = pyanaconda.baseudev.udev_enumerate_devices()
-        self.assertEqual(set(ret), 
-            set(['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda', 
-            '/devices/virtual/block/loop0', '/devices/virtual/block/loop1', 
-            '/devices/virtual/block/ram0', '/devices/virtual/block/ram1', 
+        self.assertEqual(set(ret),
+            set(['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
+            '/devices/virtual/block/loop0', '/devices/virtual/block/loop1',
+            '/devices/virtual/block/ram0', '/devices/virtual/block/ram1',
             '/devices/virtual/block/dm-0'])
         )
-        
+
     def udev_get_device_1_test(self):
         import pyanaconda.baseudev
-        
+
         class Device(object):
             def __init__(self):
                 self.sysname = 'loop1'
                 self.dict = {'symlinks': ['/dev/block/7:1'],
-                    'SUBSYSTEM': 'block', 
-                    'MAJOR': '7', 
-                    'DEVPATH': '/devices/virtual/block/loop1', 
-                    'UDISKS_PRESENTATION_NOPOLICY': '1', 
-                    'UDEV_LOG': '3', 
-                    'DEVNAME': '/dev/loop1', 
-                    'DEVTYPE': 'disk', 
-                    'DEVLINKS': '/dev/block/7:1', 
+                    'SUBSYSTEM': 'block',
+                    'MAJOR': '7',
+                    'DEVPATH': '/devices/virtual/block/loop1',
+                    'UDISKS_PRESENTATION_NOPOLICY': '1',
+                    'UDEV_LOG': '3',
+                    'DEVNAME': '/dev/loop1',
+                    'DEVTYPE': 'disk',
+                    'DEVLINKS': '/dev/block/7:1',
                     'MINOR': '1'
                 }
-                
+
             def __getitem__(self, key):
                 return self.dict[key]
-                
+
             def __setitem__(self, key, value):
                 self.dict[key] = value
-        
+
         pyanaconda.baseudev.os.path.exists.return_value = True
         DEV_PATH = '/devices/virtual/block/loop1'
         dev = Device()
         pyanaconda.baseudev.global_udev = mock.Mock()
         pyanaconda.baseudev.global_udev.create_device.return_value = dev
         pyanaconda.baseudev.udev_parse_uevent_file = mock.Mock(return_value=dev)
-        
+
         ret = pyanaconda.baseudev.udev_get_device(DEV_PATH)
         self.assertTrue(isinstance(ret, Device))
         self.assertEqual(ret['name'], ret.sysname)
@@ -87,54 +87,53 @@ class BaseudevTest(mock.TestCase):
         pyanaconda.baseudev.global_udev.create_device.return_value = None
         ret = pyanaconda.baseudev.udev_get_device('')
         self.assertEqual(ret, None)
-    
+
     def udev_get_devices_test(self):
         import pyanaconda.baseudev
         pyanaconda.baseudev.udev_settle = mock.Mock()
         DEVS = \
-            ['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda', 
-            '/devices/virtual/block/loop0', '/devices/virtual/block/loop1', 
-            '/devices/virtual/block/ram0', '/devices/virtual/block/ram1', 
+            ['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
+            '/devices/virtual/block/loop0', '/devices/virtual/block/loop1',
+            '/devices/virtual/block/ram0', '/devices/virtual/block/ram1',
             '/devices/virtual/block/dm-0']
         pyanaconda.baseudev.udev_enumerate_devices = mock.Mock(return_value=DEVS)
         pyanaconda.baseudev.udev_get_device = lambda x: x
         ret = pyanaconda.baseudev.udev_get_devices()
         self.assertEqual(ret, DEVS)
-            
+
     def udev_parse_uevent_file_1_test(self):
         import pyanaconda.baseudev
         pyanaconda.baseudev.os.path.normpath = os.path.normpath
         pyanaconda.baseudev.os.access.return_value = True
-        
+
         FILE_CONTENT = "MAJOR=7\nMINOR=1\nDEVNAME=loop1\nDEVTYPE=disk\n"
         self.fs.open('/sys/devices/virtual/block/loop1/uevent', 'w').write(FILE_CONTENT)
         dev = {'sysfs_path': '/devices/virtual/block/loop1'}
         ret = pyanaconda.baseudev.udev_parse_uevent_file(dev)
         self.assertEqual(ret,
-            {'sysfs_path': '/devices/virtual/block/loop1', 
+            {'sysfs_path': '/devices/virtual/block/loop1',
             'DEVNAME': 'loop1',
             'DEVTYPE': 'disk',
             'MAJOR': '7',
             'MINOR': '1'})
-                   
+
     def udev_parse_uevent_file_2_test(self):
         import pyanaconda.baseudev
         pyanaconda.baseudev.os.path.normpath = os.path.normpath
         pyanaconda.baseudev.os.access.return_value = False
-        
+
         dev = {'sysfs_path': '/devices/virtual/block/loop1'}
         ret = pyanaconda.baseudev.udev_parse_uevent_file(dev)
         self.assertEqual(ret, {'sysfs_path': '/devices/virtual/block/loop1'})
-   
+
     def udev_settle_test(self):
         import pyanaconda.baseudev
         pyanaconda.baseudev.iutil = mock.Mock()
         pyanaconda.baseudev.udev_settle()
         self.assertTrue(pyanaconda.baseudev.iutil.execWithRedirect.called)
-             
+
     def udev_trigger_test(self):
         import pyanaconda.baseudev
         pyanaconda.baseudev.iutil = mock.Mock()
         pyanaconda.baseudev.udev_trigger()
         self.assertTrue(pyanaconda.baseudev.iutil.execWithRedirect.called)
-        
diff --git a/tests/pyanaconda_test/desktop_test.py b/tests/pyanaconda_test/desktop_test.py
index 13f638096..d23242764 100644
--- a/tests/pyanaconda_test/desktop_test.py
+++ b/tests/pyanaconda_test/desktop_test.py
@@ -4,28 +4,28 @@ import mock
 import sys
 
 class DesktopTest(mock.TestCase):
-    
+
     def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])            
+        self.setupModules(["_isys", "block", "ConfigParser"])
         self.fs = mock.DiskIO()
-        
+
         self.fs.open('/tmp/etc/inittab', 'w').write('id:5:initdefault:')
         self.fs.open('/tmp/etc/sysconfig/desktop', 'w').write('')
-        
-        import pyanaconda.desktop     
+
+        import pyanaconda.desktop
         pyanaconda.desktop.log = mock.Mock()
         pyanaconda.desktop.open = self.fs.open
-   
+
     def tearDown(self):
         self.tearDownModules()
-        
+
     def set_default_run_level_1_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         self.assertRaises(RuntimeError, dskt.setDefaultRunLevel, 1)
         self.assertRaises(RuntimeError, dskt.setDefaultRunLevel, 2)
         self.assertRaises(RuntimeError, dskt.setDefaultRunLevel, 4)
-        
+
     def set_default_run_level_2_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
@@ -33,57 +33,57 @@ class DesktopTest(mock.TestCase):
         self.assertEqual(dskt.runlevel, 3)
         dskt.setDefaultRunLevel(5)
         self.assertEqual(dskt.runlevel, 5)
-        
+
     def get_default_run_level_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         self.assertEqual(dskt.getDefaultRunLevel(), dskt.runlevel)
-        
+
     def set_get_default_run_level_1_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.setDefaultRunLevel(3)
         self.assertEqual(dskt.getDefaultRunLevel(), 3)
-        
+
     def set_get_default_run_level_2_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.setDefaultRunLevel(5)
         self.assertEqual(dskt.getDefaultRunLevel(), 5)
-        
+
     def set_default_desktop_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.setDefaultDesktop('desktop')
         self.assertEqual(dskt.info['DESKTOP'], 'desktop')
-        
+
     def get_default_desktop_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.info['DESKTOP'] = 'foobar'
         ret = dskt.getDefaultDesktop()
         self.assertEqual(ret, 'foobar')
-        
+
     def set_get_default_desktop_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.setDefaultDesktop('foo')
         ret = dskt.getDefaultDesktop()
-        self.assertEqual(ret, 'foo')  
-        
+        self.assertEqual(ret, 'foo')
+
     def write_1_test(self):
         import pyanaconda.desktop
-        dskt = pyanaconda.desktop.Desktop()   
+        dskt = pyanaconda.desktop.Desktop()
         dskt.write('/tmp')
         self.assertEqual(self.fs['/tmp/etc/inittab'], 'id:3:initdefault:')
-        
+
     def write_2_test(self):
         import pyanaconda.desktop
         dskt = pyanaconda.desktop.Desktop()
         dskt.setDefaultRunLevel(5)
         dskt.write('/tmp')
         self.assertEqual(self.fs['/tmp/etc/inittab'], 'id:5:initdefault:')
-        
+
     def write_3_test(self):
         import pyanaconda.desktop
         pyanaconda.desktop.os = mock.Mock()
@@ -93,4 +93,4 @@ class DesktopTest(mock.TestCase):
         dskt.write('/tmp')
         self.assertEqual(self.fs['/tmp/etc/inittab'], 'id:3:initdefault:')
         self.assertEqual(self.fs['/tmp/etc/sysconfig/desktop'], 'DESKTOP="foo"\n')
-        
+