Unit tests cleanups

- make network_test, product_test, security_test, user_test and vnc_test
  pass
- remove bootloader_test.py, it is of no use now after the rewrite.
- remove trailing whitespace in network_test, product_test, users_test,
  security_test and vnc_test

6 files changed, 261 insertions, 502 deletions

diff --git a/tests/pyanaconda_test/bootloader_test.py b/tests/pyanaconda_test/bootloader_test.py
deleted file mode 100644
index 6030cafdd..000000000
--- a/tests/pyanaconda_test/bootloader_test.py
+++ /dev/null
@@ -1,181 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class BootloaderTest(mock.TestCase):
-    
-    def setUp(self):
-        self.setupModules(["_isys", "block", 'parted', 'storage',
-                            'pyanaconda.storage.formats', 'logging', 
-                            'ConfigParser', 'pyanaconda.storage.storage_log'])
-        
-        self.fs = mock.DiskIO()
-      
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-        
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.isys = mock.Mock()
-        pyanaconda.bootloader.isys.readFSLabel.return_value = ""
-        pyanaconda.bootloader.parted = mock.Mock()
-        pyanaconda.bootloader.log = mock.Mock()
-        pyanaconda.bootloader.open = self.fs.open
-   
-    def tearDown(self):
-        self.tearDownModules()
-        
-    def is_efi_system_partition_1_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = "gpt"
-        part.name = "EFI System Partition"
-        part.getFlag.return_value = True
-        part.fileSystem.type = "fat32"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)
-        self.assertTrue(ret)
-        
-    def is_efi_system_partition_2_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = ""
-        part.name = "EFI System Partition"
-        part.getFlag.return_value = True
-        part.fileSystem.type = "fat32"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)
-        self.assertFalse(ret)
-        
-    def is_efi_system_partition_3_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = "gpt"
-        part.name = ""
-        part.getFlag.return_value = True
-        part.fileSystem.type = "fat32"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)
-        self.assertFalse(ret)
-
-    def is_efi_system_partition_4_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = "gpt"
-        part.name = "EFI System Partition"
-        part.getFlag.return_value = False
-        part.fileSystem.type = "fat32"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)
-        self.assertFalse(ret)  
-        
-    def is_efi_system_partition_5_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = "gpt"
-        part.name = "EFI System Partition"
-        part.getFlag.return_value = True
-        part.fileSystem.type = "ext4"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)
-        self.assertFalse(ret)
-        
-    def is_efi_system_partition_6_test(self):
-        import pyanaconda.bootloader
-        part = mock.Mock()
-        part.disk.type = "gpt"
-        part.name = "EFI System Partition"
-        part.getFlag.return_value = True
-        part.fileSystem.type = "fat32"
-        part.getDeviceNodeName = mock.Mock()
-        pyanaconda.bootloader.isys.readFSLabel.return_value = "ANACONDA"
-        
-        ret = pyanaconda.bootloader.isEfiSystemPartition(part)       
-        self.assertFalse(ret)
-        
-    def bootloader_setup_choices_test(self):
-        import pyanaconda.bootloader
-        anaconda = mock.Mock()
-        anaconda.dir = pyanaconda.bootloader.DISPATCH_FORWARD
-        anaconda.bootloader.defaultDevice = 'dev'
-        anaconda.platform.bootloaderChoices.return_value = {'dev' : ['']}
-        pyanaconda.bootloader.bootloaderSetupChoices(anaconda)
-        
-        methods = [x[0] for x in anaconda.method_calls]
-        self.assertEqual(methods,
-            ['bootloader.updateDriveList', 'platform.bootloaderChoices', \
-            'dispatch.skip_steps', 'bootloader.images.setup', 'bootloader.setDevice']
-        )
-        
-    def fixed_mdraid_grub_target_1_test(self):
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.getReleaseString = mock.Mock(return_value=('Fedora', '13'))
-        anaconda = mock.Mock()
-        grubtarget = mock.Mock(return_value='target')
-        
-        ret = pyanaconda.bootloader.fixedMdraidGrubTarget(anaconda, grubtarget)
-        self.assertEqual(ret(), 'target')
-        
-    def fixed_mdraid_grub_target_2_test(self):
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.getDiskPart = \
-            mock.Mock(return_value=[mock.Mock(return_value='new_target')])
-        pyanaconda.bootloader.getReleaseString = mock.Mock(return_value=('Fedora', '10'))
-        anaconda = mock.Mock()
-        anaconda.bootloader.getPhysicalDevices.return_value = ['']
-        grubtarget = mock.Mock(return_value='target')
-        
-        ret = pyanaconda.bootloader.fixedMdraidGrubTarget(anaconda, grubtarget)
-        self.assertEqual(ret(), 'new_target')
-        
-    def write_bootloader_test(self):
-        import pyanaconda.bootloader
-        anaconda = mock.Mock()
-        anaconda.bootloader.defaultDevice = 1
-        anaconda.bootloader.doUpgradeOnly = False
-        anaconda.storage.rootDevice = None
-        anaconda.rootPath = ''
-        anaconda.bootloader.images.getDefault.return_value = False
-        anaconda.bootloader.images.getImages().items.return_value = \
-            [('/dev/sda1', ('label', 'long_label', None))]
-        anaconda.backend.kernelVersionList.return_value = \
-            [('2.6.33.5-124', 'i386', 'base')]
-        anaconda.bootloader.write.return_value = 0
-        
-        pyanaconda.bootloader.writeBootloader(anaconda)
-        self.assertEqual(self.fs['/etc/sysconfig/kernel'],
-            '# UPDATEDEFAULT specifies if new-kernel-pkg should make\n'
-            '# new kernels the default\nUPDATEDEFAULT=yes\n\n'
-            '# DEFAULTKERNEL specifies the default kernel package type\n'
-            'DEFAULTKERNEL=kernel\n'
-        )
-        
-        try:
-            arg = anaconda.bootloader.write.call_args_list[0][0][2]
-        except:
-            arg = None
-        self.assertEqual(arg, [('label', 'long_label', '2.6.33.5-124')])
-        
-    def has_windows_1_test(self):
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.booty.doesDualBoot = mock.Mock(return_value=False)
-        bl = mock.Mock()
-        ret = pyanaconda.bootloader.hasWindows(bl)
-        self.assertFalse(ret)
-        
-    def has_windows_2_test(self):
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.booty.doesDualBoot = mock.Mock(return_value=True)
-        bl = mock.Mock()
-        bl.images.availableBootDevices.return_value = []
-        ret = pyanaconda.bootloader.hasWindows(bl)
-        self.assertFalse(ret)
-        
-    def has_windows_3_test(self):
-        import pyanaconda.bootloader
-        pyanaconda.bootloader.booty.doesDualBoot = mock.Mock(return_value=True)
-        pyanaconda.bootloader.booty.dosFileSystems = mock.Mock(return_value=True)
-        bl = mock.Mock()
-        bl.images.availableBootDevices.return_value = [('', 'fat32')]
-        ret = pyanaconda.bootloader.hasWindows(bl)
-        self.assertTrue(ret)
-        
diff --git a/tests/pyanaconda_test/network_test.py b/tests/pyanaconda_test/network_test.py
index e044d3965..96717cd09 100644
--- a/tests/pyanaconda_test/network_test.py
+++ b/tests/pyanaconda_test/network_test.py
@@ -4,27 +4,27 @@ import mock
 import os
 
 class NetworkTest(mock.TestCase):
-    
+
     def setUp(self):
         self.setupModules(['_isys', 'block', 'logging', 'ConfigParser'])
         self.fs = mock.DiskIO()
-        
+
         self.OK = 22
         self.SYSCONFIGDIR = "/tmp/etc/sysconfig"
         self.NETSCRIPTSDIR = "%s/network-scripts" % (self.SYSCONFIGDIR)
         self.NETWORKCONFFILE = '%s/network' % self.SYSCONFIGDIR
         self.IFCFGLOG = '/tmp/ifcfg.log'
         self.DEFAULT_HOSTNAME = 'localhost.localdomain'
-        
+
         self.CONT = "DEVICE=eth0\nHWADDR=00:11:22:50:55:50\nTYPE=Ethernet\nBOOTPROTO=dhcp\n"
         self.DEVICE = 'eth0'
         self.DEV_FILE =  self.NETSCRIPTSDIR + '/ifcfg-eth0'
         self.DEV_KEY_FILE =  self.NETSCRIPTSDIR + '/keys-eth0'
         self.fs.open(self.DEV_FILE, 'w').write(self.CONT)
-        
+
         import pyanaconda
         pyanaconda.anaconda_log = mock.Mock()
-               
+
         import pyanaconda.network
         pyanaconda.network.socket = mock.Mock()
         pyanaconda.network.socket.gethostname.return_value = self.DEFAULT_HOSTNAME
@@ -35,7 +35,7 @@ class NetworkTest(mock.TestCase):
         pyanaconda.network.networkConfFile = self.NETWORKCONFFILE
         pyanaconda.network.ifcfgLogFile = self.IFCFGLOG
         self.fs.open(self.IFCFGLOG, 'w')
-        
+
         # Network mock
         pyanaconda.network.Network.update = mock.Mock()
         self.controlWireless_backup = pyanaconda.network.Network.controlWireless
@@ -43,7 +43,7 @@ class NetworkTest(mock.TestCase):
         self.setNMControlledDevices_backup = pyanaconda.network.Network.setNMControlledDevices
         pyanaconda.network.Network.setNMControlledDevices = mock.Mock()
         pyanaconda.network.Network.netdevices = {}
-          
+
     def tearDown(self):
         self.tearDownModules()
 
@@ -74,33 +74,33 @@ class NetworkTest(mock.TestCase):
 
     def get_default_hostname_1_test(self):
         import pyanaconda.network
-        
+
         HOSTNAME = 'host1'
         pyanaconda.network.getActiveNetDevs = mock.Mock(return_value=['dev'])
         pyanaconda.network.isys = mock.Mock()
         pyanaconda.network.isys.getIPAddresses.return_value = ['10.0.0.1']
         pyanaconda.network.socket = mock.Mock()
         pyanaconda.network.socket.gethostbyaddr.return_value = [HOSTNAME, '', '']
-        
+
         ret = pyanaconda.network.getDefaultHostname(mock.Mock())
         self.assertEqual(ret, HOSTNAME)
 
     def get_default_hostname_2_test(self):
         import pyanaconda.network
-        
+
         HOSTNAME = 'host2'
         pyanaconda.network.getActiveNetDevs = mock.Mock(return_value=[])
         pyanaconda.network.isys = mock.Mock()
         pyanaconda.network.socket = mock.Mock()
         anaconda = mock.Mock()
         anaconda.network.hostname = HOSTNAME
-        
+
         ret = pyanaconda.network.getDefaultHostname(anaconda)
         self.assertEqual(ret, HOSTNAME)
 
     def get_default_hostname_3_test(self):
         import pyanaconda.network
-        
+
         HOSTNAME = 'host3'
         pyanaconda.network.getActiveNetDevs = mock.Mock(return_value=[])
         pyanaconda.network.isys = mock.Mock()
@@ -108,110 +108,104 @@ class NetworkTest(mock.TestCase):
         pyanaconda.network.socket.gethostname.return_value = HOSTNAME
         anaconda = mock.Mock()
         anaconda.network.hostname = ''
-        
+
         ret = pyanaconda.network.getDefaultHostname(anaconda)
         self.assertEqual(ret, HOSTNAME)
 
     def get_default_hostname_4_test(self):
         import pyanaconda.network
-        
+
         pyanaconda.network.getActiveNetDevs = mock.Mock(return_value=[])
         pyanaconda.network.isys = mock.Mock()
         pyanaconda.network.socket = mock.Mock()
         pyanaconda.network.socket.gethostname.return_value = ''
         anaconda = mock.Mock()
         anaconda.network.hostname = ''
-        
+
         ret = pyanaconda.network.getDefaultHostname(anaconda)
         self.assertEqual(ret, self.DEFAULT_HOSTNAME)
 
     def sanity_check_ip_string_1_test(self):
         import pyanaconda.network
-        
+
         IPADDR = '10.0.0.5'
         pyanaconda.network.sanityCheckIPString(IPADDR)
 
     def sanity_check_ip_string_2_test(self):
         import pyanaconda.network
-        
+
         IPADDR = "ff06:0:0:0:0:0:0:c3"
         pyanaconda.network.sanityCheckIPString(IPADDR)
 
     def sanity_check_ip_string_3_test(self):
         import pyanaconda.network
-        
+
         IPADDR = "ff06:.:.:0:0:0:0:c3"
-        self.assertRaises(pyanaconda.network.IPError, 
+        self.assertRaises(pyanaconda.network.IPError,
             pyanaconda.network.sanityCheckIPString, IPADDR)
 
     def sanity_check_ip_string_4_test(self):
         import pyanaconda.network
-        import socket       
+        import socket
         pyanaconda.network.socket.error = socket.error
         pyanaconda.network.socket.inet_pton = mock.Mock(side_effect=socket.error)
-        
+
         IPADDR = "1.8.64.512"
         self.assertRaises(pyanaconda.network.IPError,
             pyanaconda.network.sanityCheckIPString, IPADDR)
 
     def sanity_check_ip_string_5_test(self):
         import pyanaconda.network
-        import socket       
+        import socket
         pyanaconda.network.socket.error = socket.error
         pyanaconda.network.socket.inet_pton = mock.Mock(side_effect=socket.error)
-        
+
         IPADDR = "top.secret.address"
-        self.assertRaises(pyanaconda.network.IPError, 
+        self.assertRaises(pyanaconda.network.IPError,
             pyanaconda.network.sanityCheckIPString, IPADDR)
 
     def has_active_net_dev_1_test(self):
         import pyanaconda.network
-        
+
         pyanaconda.network.dbus = mock.Mock()
-        pyanaconda.network.dbus.Interface().Get.return_value = self.OK
-        pyanaconda.network.isys.NM_STATE_CONNECTED = self.OK
-        
+        pyanaconda.network.dbus.Interface().Get.return_value = \
+            pyanaconda.network.isys.NM_STATE_CONNECTED_GLOBAL
+
         ret = pyanaconda.network.hasActiveNetDev()
         self.assertTrue(ret)
+        self.assertTrue(pyanaconda.network.dbus.Interface().Get.called)
 
     def has_active_net_dev_2_test(self):
         import pyanaconda.network
-        
+
         pyanaconda.network.dbus = mock.Mock(side_effect=Exception)
-        
+
         ret = pyanaconda.network.hasActiveNetDev()
         self.assertFalse(ret)
 
     def has_active_net_dev_3_test(self):
         import pyanaconda.network
-        
+
         pyanaconda.network.dbus = mock.Mock()
         pyanaconda.network.dbus.Interface().Get.return_value = self.OK
         pyanaconda.network.isys.NM_STATE_CONNECTED = (self.OK - 5)
-        
+
         ret = pyanaconda.network.hasActiveNetDev()
         self.assertFalse(ret)
-    
-    #def get_active_net_devs_test(self):
-    #    pass
-
-    ##
-    ## NetworkDevice class tests
-    ##
 
     def networkdevice_read_test(self):
         import pyanaconda.network
-        
+
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         ret = nd.read()
         self.assertEqual(ret, 4)
-        self.assertEqual(nd.info, 
-            {'DEVICE': 'eth0', 'HWADDR': '00:11:22:50:55:50', 
+        self.assertEqual(nd.info,
+            {'DEVICE': 'eth0', 'HWADDR': '00:11:22:50:55:50',
             'BOOTPROTO': 'dhcp', 'TYPE': 'Ethernet'})
 
     def networkdevice_clear_test(self):
         import pyanaconda.network
-        
+
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.info = {'DEVICE': 'eth0', 'HWADDR': '00:11:22:50:55:50', 'TYPE': 'Ethernet'}
         nd.clear()
@@ -221,10 +215,11 @@ class NetworkTest(mock.TestCase):
         import pyanaconda.network
         pyanaconda.network.iutil = mock.Mock()
         pyanaconda.network.iutil.isS390.return_value = False
-        
+
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.info = {'HWADDR': '00:11:22:50:55:50', 'DEVICE': 'eth0', 'TYPE': 'Ethernet'}
-        self.assertTrue(str(nd).startswith('DEVICE="eth0"'))
+        self.assertIn('DEVICE="eth0"', str(nd))
+        self.assertIn('TYPE="Ethernet"', str(nd))
 
     def networkdevice_load_ifcfg_file_test(self):
         import pyanaconda.network
@@ -232,25 +227,26 @@ class NetworkTest(mock.TestCase):
         nd.loadIfcfgFile()
         self.assertFalse(nd._dirty)
         self.assertEqual(nd.info,
-            {'DEVICE': 'eth0', 'HWADDR': '00:11:22:50:55:50', 
+            {'DEVICE': 'eth0', 'HWADDR': '00:11:22:50:55:50',
             'TYPE': 'Ethernet', 'BOOTPROTO': 'dhcp'})
-    
+
     def networkdevice_write_ifcfg_file_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.info = {'HWADDR': '66:55:44:33:22:11', 'DEVICE': 'eth1', 'TYPE': 'Ethernet'}
         nd._dirty = True
         nd.writeIfcfgFile()
-        self.assertEqual(self.fs[self.DEV_FILE],    
-            'DEVICE="eth1"\nHWADDR="66:55:44:33:22:11"\nTYPE="Ethernet"\n')
-    
+        self.assertIn('DEVICE="eth1"\n', self.fs[self.DEV_FILE])
+        self.assertIn('HWADDR="66:55:44:33:22:11"', self.fs[self.DEV_FILE])
+        self.assertIn('TYPE="Ethernet"', self.fs[self.DEV_FILE])
+
     def networkdevice_set_1_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.set(('key', 'value'))
         self.assertEqual(nd.info, {'KEY': 'value'})
         self.assertTrue(nd._dirty)
-        
+
     def networkdevice_set_2_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
@@ -258,7 +254,7 @@ class NetworkTest(mock.TestCase):
         nd.set(('key', 'other_value'))
         self.assertEqual(nd.info, {'KEY': 'other_value'})
         self.assertTrue(nd._dirty)
-        
+
     def networkdevice_set_3_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
@@ -267,20 +263,20 @@ class NetworkTest(mock.TestCase):
         nd.set(('key', 'other_value'))
         self.assertEqual(nd.info, {'KEY': 'other_value'})
         self.assertTrue(nd._dirty)
-        
+
     def networkdevice_keyfile_path_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         ret = nd.keyfilePath
         self.assertEqual(ret, self.DEV_KEY_FILE)
-        
+
     def networkdevice_write_wepkey_file_1_test(self):
         import pyanaconda.network
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.wepkey = False
         ret = nd.writeWepkeyFile()
         self.assertFalse(ret)
-        
+
     def networkdevice_write_wepkey_file_2_test(self):
         import pyanaconda.network
         TMP_FILE = '/tmp/wep.key'
@@ -290,54 +286,38 @@ class NetworkTest(mock.TestCase):
         pyanaconda.network.os = mock.Mock()
         pyanaconda.network.os.path = os.path
         pyanaconda.network.shutil = mock.Mock()
-        
+
         nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
         nd.iface = self.DEVICE
         nd.wepkey = '12345'
-        
+
         nd.writeWepkeyFile(dir=TMP_DIR)
         self.assertEqual(pyanaconda.network.os.write.call_args[0], (88, 'KEY1=12345\n'))
         self.assertEqual(pyanaconda.network.shutil.move.call_args[0],
             (TMP_FILE, '%s/keys-%s' % (TMP_DIR, self.DEVICE)))
-           
-    #def networkdevice_used_by_fcoe_test(self):
-    #    pass
-    
-    #dev networkdevice_used_by_root_on_iscsi_test(self):
-    #    pass
-    
-    #def networkdevice_used_by_iscsi_test(self):
-    #    pass
-    
-    ##
-    ## Network class tests
-    ##
-    
-    #def network_update_test(self):
-    #    pass
-    
+
     def network_get_device_test(self):
-        import pyanaconda.network       
-        
+        import pyanaconda.network
+
         nw = pyanaconda.network.Network()
         nw.netdevices['dev'] = 'device'
         ret = nw.getDevice('dev')
         self.assertEqual(ret, 'device')
-        
+
     def network_get_ks_device_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.ksdevice = None
         ret = nw.getKSDevice()
         self.assertEqual(ret, None)
-    
+
     def network_get_ks_device_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.ksdevice = 'ksdev'
         ret = nw.getKSDevice()
         self.assertEqual(ret, None)
-    
+
     def network_get_ks_device_3_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -345,23 +325,24 @@ class NetworkTest(mock.TestCase):
         nw.ksdevice = 'ksdev'
         ret = nw.getKSDevice()
         self.assertEqual(ret, 'device')
-    
+
     def network_set_hostname_test(self):
         import pyanaconda.network
+        pyanaconda.network.iutil.execWithRedirect = mock.Mock()
         nw = pyanaconda.network.Network()
         nw.setHostname('DESKTOP')
         self.assertEqual(nw.hostname, 'DESKTOP')
-        
+
     def network_set_dns_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices['dev'] = mock.Mock()
         nw.setDNS('10.0.0.1, 10.0.0.2', 'dev')
-        self.assertEqual(nw.netdevices['dev'].method_calls, 
-            [('set', (('DNS1', '10.0.0.1'),), {}), 
+        self.assertEqual(nw.netdevices['dev'].method_calls,
+            [('set', (('DNS1', '10.0.0.1'),), {}),
             ('set', (('DNS2', '10.0.0.2'),), {})]
         )
-        
+
     def network_set_gateway_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -369,14 +350,14 @@ class NetworkTest(mock.TestCase):
         nw.setGateway('10.0.0.1', 'eth0')
         self.assertEqual(pyanaconda.network.Network.netdevices['eth0'].method_calls,
             [('set', (('GATEWAY', '10.0.0.1'),), {})])
-    
+
     def network_lookup_hostname_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.hostname = None
         ret = nw.lookupHostname()
         self.assertEqual(ret, None)
-    
+
     def network_lookup_hostname_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -384,66 +365,66 @@ class NetworkTest(mock.TestCase):
         pyanaconda.network.hasActiveNetDev = mock.Mock(return_value=False)
         ret = nw.lookupHostname()
         self.assertEqual(ret, None)
-    
+
     def network_lookup_hostname_3_test(self):
         import pyanaconda.network
         pyanaconda.network.socket.getaddrinfo.return_value = \
             [(0, 0, 0, 0, ('10.1.1.1', 0))]
-        
+
         nw = pyanaconda.network.Network()
         nw.hostname = 'desktop'
         pyanaconda.network.hasActiveNetDev = mock.Mock(return_value=True)
         ret = nw.lookupHostname()
         self.assertEqual(ret, '10.1.1.1')
-    
+
     def network_write_ifcfg_files_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         nw.writeIfcfgFiles()
         self.assertTrue(nw.netdevices['dev'].writeIfcfgFile.called)
-        
+
     def network_nm_controlled_devices_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         pyanaconda.network.Network.setNMControlledDevices = self.setNMControlledDevices_backup
         nw.setNMControlledDevices()
-        self.assertEqual(nw.netdevices['dev'].method_calls, 
+        self.assertEqual(nw.netdevices['dev'].method_calls,
             [('set', (('NM_CONTROLLED', 'yes'),), {})])
-    
+
     def network_nm_controlled_devices_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         pyanaconda.network.Network.setNMControlledDevices = self.setNMControlledDevices_backup
         nw.setNMControlledDevices([''])
-        self.assertEqual(nw.netdevices['dev'].method_calls, 
+        self.assertEqual(nw.netdevices['dev'].method_calls,
             [('set', (('NM_CONTROLLED', 'no'),), {})])
-    
+
     def network_update_active_devices_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         nw.updateActiveDevices()
-        self.assertEqual(nw.netdevices['dev'].method_calls, 
+        self.assertEqual(nw.netdevices['dev'].method_calls,
             [('set', (('ONBOOT', 'yes'),), {})])
-        
+
     def network_update_active_devices_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         nw.updateActiveDevices([''])
-        self.assertEqual(nw.netdevices['dev'].method_calls, 
+        self.assertEqual(nw.netdevices['dev'].method_calls,
             [('set', (('ONBOOT', 'no'),), {})])
-            
+
     def network_get_on_boot_controlled_ifaces_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
         nw.netdevices = {'dev': mock.Mock()}
         ret = nw.getOnbootControlledIfaces()
         self.assertEqual(ret, [])
-        
+
     def network_get_on_boot_controlled_ifaces_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -452,7 +433,7 @@ class NetworkTest(mock.TestCase):
         nw.netdevices = {'dev': a}
         ret = nw.getOnbootControlledIfaces()
         self.assertEqual(ret, ['dev'])
-        
+
     def network_update_ifcfg_ssid_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -462,10 +443,7 @@ class NetworkTest(mock.TestCase):
             ('set', (('ESSID', 'net_essid'),), {}))
         self.assertEqual(nw.netdevices['dev'].method_calls[1],
             ('writeIfcfgFile', (), {}))
-    
-    #def network_get_ssids_test(self):
-    #    pass
-    
+
     def network_select_preferred_ssids_1_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -474,7 +452,7 @@ class NetworkTest(mock.TestCase):
         dev_ssid = {'dev': ['some_essid']}
         nw.selectPreferredSSIDs(dev_ssid)
         self.assertEqual(dev_ssid, {'dev': ['some_essid']})
-    
+
     def network_select_preferred_ssids_2_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -483,7 +461,7 @@ class NetworkTest(mock.TestCase):
         dev_ssid = {'dev': ['some_essid', 'other']}
         nw.selectPreferredSSIDs(dev_ssid)
         self.assertEqual(dev_ssid, {'dev': ['some_essid']})
-    
+
     def network_select_preferred_ssids_3_test(self):
         import pyanaconda.network
         nw = pyanaconda.network.Network()
@@ -492,7 +470,7 @@ class NetworkTest(mock.TestCase):
         dev_ssid = {'dev': ['other', 'foo']}
         nw.selectPreferredSSIDs(dev_ssid)
         self.assertEqual(dev_ssid, {'dev': ['other', 'foo']})
-        
+
     def network_control_wireless_test(self):
         import pyanaconda.network
         pyanaconda.network.isys = mock.Mock()
@@ -503,38 +481,38 @@ class NetworkTest(mock.TestCase):
         nw.controlWireless()
         self.assertEqual(nw.netdevices['dev'].method_calls,
             [('set', (('NM_CONTROLLED', 'yes'),), {})])
-        
+
     def network_write_ks_test(self):
         import pyanaconda.network
         TMPFILE = '/tmp/networkKS'
         f = self.fs.open(TMPFILE, 'w')
-        
+
         nw = pyanaconda.network.Network()
         nw.netdevices[self.DEVICE] = pyanaconda.network.NetworkDevice(
             self.NETSCRIPTSDIR, self.DEVICE)
         nw.netdevices[self.DEVICE].loadIfcfgFile()
         nw.writeKS(f)
         f.close()
-        
-        self.assertEqual(self.fs[TMPFILE], 
+
+        self.assertEqual(self.fs[TMPFILE],
             'network --device eth0 --bootproto dhcp --noipv6\n')
-    
+
     def network_has_name_server_1_test(self):
         import pyanaconda.network
         hash = {'foo':'', 'bar':''}
-        
+
         nw = pyanaconda.network.Network()
         ret = nw.hasNameServers(hash)
         self.assertFalse(ret)
-    
+
     def network_has_name_server_2_test(self):
         import pyanaconda.network
         hash = {'foo':'', 'bar':'', 'dnsserver':''}
-        
+
         nw = pyanaconda.network.Network()
         ret = nw.hasNameServers(hash)
         self.assertTrue(ret)
-        
+
     def network_has_wireless_dev_1_test(self):
         import pyanaconda.network
         pyanaconda.network.isys = mock.Mock()
@@ -544,7 +522,7 @@ class NetworkTest(mock.TestCase):
         nw.netdevices = {'dev': ''}
         ret = nw.hasWirelessDev()
         self.assertTrue(ret)
-        
+
     def network_has_wireless_dev_2_test(self):
         import pyanaconda.network
         pyanaconda.network.isys = mock.Mock()
@@ -554,80 +532,73 @@ class NetworkTest(mock.TestCase):
         nw.netdevices = {'dev': ''}
         ret = nw.hasWirelessDev()
         self.assertFalse(ret)
-    
-    #def network_copy_file_to_path_test(self):
-    #    pass
-    
+
     def network_copy_config_to_path_test(self):
         import pyanaconda.network
         pyanaconda.network.Network._copyFileToPath = mock.Mock()
-        
+
         nw = pyanaconda.network.Network()
         nw.netdevices['dev'] = mock.Mock()
         nw.netdevices['dev'].path = self.DEV_FILE
         nw.netdevices['dev'].keyfilePath = self.DEV_KEY_FILE
         ret = nw.copyConfigToPath('')
         self.assertEqual(pyanaconda.network.Network._copyFileToPath.call_args_list,
-            [(('/tmp/etc/sysconfig/network-scripts/ifcfg-eth0', ''), {}), 
-             (('/tmp/etc/sysconfig/network-scripts/keys-eth0', ''), {}), 
-             (('/etc/dhcp/dhclient-dev.conf', ''), {}), 
-             (('/tmp/etc/sysconfig/network', ''), {'overwrite': 0}), 
-             (('/etc/resolv.conf', ''), {'overwrite': 0}), 
+            [(('/tmp/etc/sysconfig/network-scripts/ifcfg-eth0', ''), {}),
+             (('/tmp/etc/sysconfig/network-scripts/keys-eth0', ''), {}),
+             (('/etc/dhcp/dhclient-dev.conf', ''), {}),
+             (('/tmp/etc/sysconfig/network', ''), {'overwrite': 0}),
+             (('/etc/resolv.conf', ''), {'overwrite': 0}),
              (('/etc/udev/rules.d/70-persistent-net.rules', ''), {'overwrite': 0})]
         )
-    
+
     def network_disable_nm_for_storage_devices_test(self):
         import pyanaconda.network
         pyanaconda.network.NetworkDevice = mock.Mock()
         pyanaconda.network.os = mock.Mock()
         pyanaconda.network.os.access.return_value = True
-        
+
         nw = pyanaconda.network.Network()
         nw.netdevices['dev'] = mock.Mock()
         anaconda= mock.Mock()
-        
+
         nw.disableNMForStorageDevices(anaconda, '')
-        self.assertEqual(pyanaconda.network.NetworkDevice.call_args_list, 
+        self.assertEqual(pyanaconda.network.NetworkDevice.call_args_list,
              [(('/tmp/etc/sysconfig/network-scripts', 'dev'), {})])
-        self.assertEqual(pyanaconda.network.NetworkDevice().method_calls, 
-            [('loadIfcfgFile', (), {}), 
-             ('set', (('NM_CONTROLLED', 'no'),), {}), 
+        self.assertEqual(pyanaconda.network.NetworkDevice().method_calls,
+            [('loadIfcfgFile', (), {}),
+             ('set', (('NM_CONTROLLED', 'no'),), {}),
              ('writeIfcfgFile', (), {})]
          )
-         
+
     def network_write_test(self):
         import pyanaconda.network
         pyanaconda.network.shutil = mock.Mock()
         pyanaconda.network.os = mock.Mock()
         pyanaconda.network.os.path.isfile.return_value = True
         self.fs.open(self.NETWORKCONFFILE, 'w')
-        
+
         device = pyanaconda.network.NetworkDevice(
             self.NETSCRIPTSDIR, self.DEVICE)
         device.loadIfcfgFile()
-        
+
         nw = pyanaconda.network.Network()
         nw.domains = ['localdomain']
         nw.netdevices[self.DEVICE] = device
         nw.write()
-        
-        self.assertEqual(self.fs['%s.new' % self.NETWORKCONFFILE], 
+
+        self.assertEqual(self.fs['%s.new' % self.NETWORKCONFFILE],
             'NETWORKING=yes\nHOSTNAME=localhost.localdomain\n')
-        
-    #def network_wait_for_devices_activation_test(self):
-    #    pass
-    
+
     def network_wait_for_connection_1_test(self):
         import pyanaconda.network
         pyanaconda.network.dbus = mock.Mock()
-        pyanaconda.network.dbus.Interface().Get.return_value = self.OK
-        pyanaconda.network.isys = mock.Mock()
-        pyanaconda.network.isys.NM_STATE_CONNECTED = self.OK
-        
+        pyanaconda.network.dbus.Interface().Get.return_value = \
+            pyanaconda.network.isys.NM_STATE_CONNECTED_GLOBAL
+
         nw = pyanaconda.network.Network()
         ret = nw.waitForConnection()
         self.assertTrue(ret)
-        
+
     def network_wait_for_connection_2_test(self):
         import pyanaconda.network
         pyanaconda.network.dbus = mock.Mock()
@@ -635,35 +606,26 @@ class NetworkTest(mock.TestCase):
         pyanaconda.network.isys = mock.Mock()
         pyanaconda.network.isys.NM_STATE_CONNECTED = self.OK
         pyanaconda.network.time.sleep = mock.Mock()
-        
+
         nw = pyanaconda.network.Network()
         ret = nw.waitForConnection()
         self.assertFalse(ret)
-        
+
     def network_bring_up_test(self):
         import pyanaconda.network
         pyanaconda.network.Network.write = mock.Mock()
         pyanaconda.network.Network.waitForConnection = mock.Mock()
-        
+
         nw = pyanaconda.network.Network()
         nw.bringUp()
         self.assertTrue(pyanaconda.network.Network.write.called)
         self.assertTrue(pyanaconda.network.Network.waitForConnection.called)
-    
-    #def network_dracut_setup_string_test(self):
-    #    import pyanaconda.network
-    #    pass
-    
-    #def get_ssids_test(self):
-    #    import pyanaconda.network
-    #    pass
-    
+
     def iface_for_host_ip_test(self):
         import pyanaconda.network
         pyanaconda.network.iutil = mock.Mock()
         pyanaconda.network.iutil.execWithCapture.return_value = \
             "10.0.0.2 dev eth0  src 10.0.0.1"
-        
+
         ret = pyanaconda.network.ifaceForHostIP('10.0.0.2')
         self.assertEqual(ret, 'eth0')
-        
diff --git a/tests/pyanaconda_test/product_test.py b/tests/pyanaconda_test/product_test.py
index 74b285a3a..f8b2e0c7c 100644
--- a/tests/pyanaconda_test/product_test.py
+++ b/tests/pyanaconda_test/product_test.py
@@ -7,20 +7,18 @@ import __builtin__
 import ConfigParser
 
 class ProductTest(mock.TestCase):
-    
+
     def setUp(self):
         self.setupModules(['_isys', 'block', 'os'])
         self.fs = mock.DiskIO()
-        
-        del sys.modules['pyanaconda.product']
-              
+
         # os module global mock
         self.modifiedModule("os")
         os = sys.modules['os']
         os.access = mock.Mock(return_value=False)
         os.uname.return_value = ('', '', '', '', 'i386')
-        os.environ = {}      
-    
+        os.environ = {}
+
         # fake /tmp/product/.buildstamp file
         self.BUGURL = 'http://bug.url'
         self.BETA = 'true'
@@ -38,33 +36,33 @@ class ProductTest(mock.TestCase):
         "UUID: %s\n"\
         "Version: %s\n" % \
         (self.BUGURL, self.BETA, self.ARCH, self.NAME, self.UUID, self.VERSION)
-        
+
         self.fs.open(self.FILENAME, 'w').write(self.FILE)
-        
+
         # mock builtin open function
         self.open = __builtin__.open
         __builtin__.open = self.fs.open
-        
+
     def tearDown(self):
         __builtin__.open = self.open
         self.tearDownModules()
-    
-   
+
+
     def bug_url_test(self):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
         self.assertEqual(pyanaconda.product.bugUrl, self.BUGURL)
-    
+
     def is_beta_test(self):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
         self.assertTrue(pyanaconda.product.isBeta)
-    
+
     def product_arch_test(self):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
         self.assertEqual(pyanaconda.product.productArch, self.ARCH)
-   
+
     def product_name_test(self):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
@@ -74,7 +72,7 @@ class ProductTest(mock.TestCase):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
         self.assertEqual(pyanaconda.product.productStamp, self.UUID)
-    
+
     def product_version_test(self):
         sys.modules['os'].access = mock.Mock(return_value=True)
         import pyanaconda.product
diff --git a/tests/pyanaconda_test/security_test.py b/tests/pyanaconda_test/security_test.py
index a9254022b..623f8614b 100644
--- a/tests/pyanaconda_test/security_test.py
+++ b/tests/pyanaconda_test/security_test.py
@@ -6,78 +6,81 @@ import sys
 class SecurityTest(mock.TestCase):
     def setUp(self):
         self.setupModules(["_isys", "block", "ConfigParser"])
-        
+
         self.fs = mock.DiskIO()
-        
-        import pyanaconda.security 
+
+        import pyanaconda.security
         pyanaconda.security.log = mock.Mock()
         pyanaconda.security.open = self.fs.open
         pyanaconda.security.iutil = mock.Mock()
-   
+
+        import pyanaconda.flags
+        pyanaconda.flags.flags.selinux = 1
+
     def tearDown(self):
         self.tearDownModules()
-        
+
     def set_get_selinux_test(self):
         import pyanaconda.security
-        
-        states = pyanaconda.security.selinux_states           
+
+        states = pyanaconda.security.selinux_states
         scrt = pyanaconda.security.Security()
-        
+
         for state in states:
             scrt.setSELinux(state)
             self.assertEqual(scrt.getSELinux(), state)
 
     def set_get_selinux_bad_sate_test(self):
         import pyanaconda.security
-        
+
         states = pyanaconda.security.selinux_states
         scrt = pyanaconda.security.Security()
         scrt.setSELinux('bad_state')
         self.assertTrue(scrt.getSELinux() in states)
-        
+
     def write_ks_1_test(self):
         """Simulate writing security to kickstart (1)"""
-        import pyanaconda.security 
-                   
+        import pyanaconda.security
+
         scrt = pyanaconda.security.Security()
         f = self.fs.open('/tmp/security_ks1', 'w')
         scrt.writeKS(f)
         f.close()
-        
-        self.assertEqual(self.fs['/tmp/security_ks1'], 
-            'selinux --enforcing\nauthconfig --enableshadow --passalgo=sha512 --enablefingerprint\n')
-            
+
+        self.assertEqual(self.fs['/tmp/security_ks1'],
+            'selinux --enforcing\nauthconfig --enableshadow --passalgo=sha512\n')
+
     def write_ks_2_test(self):
         """Simulate writing security to kickstart (2)"""
-        import pyanaconda.security 
-                   
+        import pyanaconda.security
+
         scrt = pyanaconda.security.Security()
         scrt.selinux = pyanaconda.security.SELINUX_DISABLED
         f = self.fs.open('/tmp/security_ks2', 'w')
         scrt.writeKS(f)
         f.close()
-        
-        self.assertEqual(self.fs['/tmp/security_ks2'], 
-            'selinux --disabled\nauthconfig --enableshadow --passalgo=sha512 --enablefingerprint\n')
-            
+
+        self.assertEqual(self.fs['/tmp/security_ks2'],
+            'selinux --disabled\nauthconfig --enableshadow --passalgo=sha512\n')
+
     def write_test(self):
         """Simulate writing security (simulate executing lokkit and authconfig)"""
-        import pyanaconda.security 
-                   
+        import pyanaconda.security
+
         scrt = pyanaconda.security.Security()
-        scrt.write('/tmp/security')    
-        
-        self.assertEqual(pyanaconda.security.iutil.method_calls, 
-            [('execWithRedirect', 
-                ('/usr/sbin/lokkit', ['--selinux=enforcing']), 
+        scrt.write('/tmp/security')
+
+        self.assertEqual(pyanaconda.security.iutil.method_calls,
+            [('execWithRedirect',
+                ('/usr/sbin/lokkit', ['--selinux=enforcing']),
                 {'root': '/tmp/security', 'stderr': '/dev/null', 'stdout': '/dev/null'}
-             ), 
-             ('execWithRedirect', 
-                ('/usr/sbin/authconfig', 
-                    ['--update', '--nostart', '--enableshadow', '--passalgo=sha512', '--enablefingerprint']
-                ), 
+             ),
+             ('resetRpmDb', ('/tmp/security',), {}),
+             ('execWithRedirect',
+                ('/usr/sbin/authconfig',
+                    ['--update', '--nostart', '--enableshadow', '--passalgo=sha512']
+                ),
                 {'root': '/tmp/security', 'stderr': '/dev/tty5', 'stdout': '/dev/tty5'}
              )
             ]
-        )    
-        
+        )
diff --git a/tests/pyanaconda_test/users_test.py b/tests/pyanaconda_test/users_test.py
index 6e34fa8a9..e34bb9ed3 100644
--- a/tests/pyanaconda_test/users_test.py
+++ b/tests/pyanaconda_test/users_test.py
@@ -9,134 +9,134 @@ HOMEDIRECTORY = 'pw_dir'
 class UsersTest(mock.TestCase):
     def setUp(self):
         self.setupModules(["_isys", "block", "ConfigParser"])
-        
+
         self.fs = mock.DiskIO()
         self.anaconda = mock.Mock()
         self.anaconda.security.auth.find.return_value = -1
-        
-        import pyanaconda.users 
+
+        import pyanaconda.users
         pyanaconda.users.log = mock.Mock()
         pyanaconda.users.iutil = mock.Mock()
         pyanaconda.users.iutil.mkdirChain = mock.Mock()
-        
+
         pyanaconda.users.os = mock.Mock()
         pyanaconda.users.os.fork.return_value=False
         pyanaconda.users.os.waitpid.return_value=(1, 1)
         pyanaconda.users.os.WEXITSTATUS.return_value=0
-        
+
         pyanaconda.users.libuser.admin = mock.Mock()
         pyanaconda.users.libuser.GIDNUMBER = GIDNUMBER
-        pyanaconda.users.libuser.HOMEDIRECTORY = HOMEDIRECTORY        
-        pyanaconda.users.libuser.admin().lookupGroupByName.return_value = False        
+        pyanaconda.users.libuser.HOMEDIRECTORY = HOMEDIRECTORY
+        pyanaconda.users.libuser.admin().lookupGroupByName.return_value = False
         pyanaconda.users.libuser.admin().lookupUserByName.return_value = False
         pyanaconda.users.libuser.admin().initGroup().get.return_value = ['']
         pyanaconda.users.libuser.admin().initGroup().reset_mock()
         pyanaconda.users.libuser.admin().reset_mock()
-    
+
     def tearDown(self):
         self.tearDownModules()
-    
+
     def create_group_test(self):
-        import pyanaconda.users     
- 
+        import pyanaconda.users
+
         GROUP = 'Group'
         GID = 100
- 
+
         usr = pyanaconda.users.Users(self.anaconda)
-        self.assertTrue(usr.createGroup(GROUP, GID, root=''))
-      
+        self.assertTrue(usr.createGroup(GROUP, gid=GID, root=''))
+
         methods = pyanaconda.users.libuser.admin().method_calls[:]
         try:
             if methods[2][0] == 'addGroup':
                 methods.pop()
         except:
             pass
-           
-        self.assertEqual(methods,        
+
+        self.assertEqual(methods,
             [('lookupGroupByName', (GROUP,), {}), ('initGroup', (GROUP,), {}),])
-        
+
         self.assertEqual(
             pyanaconda.users.libuser.admin().initGroup().method_calls,
             [('set', (GIDNUMBER, GID), {})])
-        
+
     def create_user_test(self):
-        import pyanaconda.users     
- 
+        import pyanaconda.users
+
         USER = 'TestUser'
         PASS = 'abcde'
- 
+
         usr = pyanaconda.users.Users(self.anaconda)
-        self.assertTrue(usr.createUser(USER, PASS, root=''))
-  
+        self.assertTrue(usr.createUser(USER, password=PASS, root=''))
+
         self.assertTrue(pyanaconda.users.iutil.mkdirChain.called)
-        
+
         methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
-        self.assertEqual(methods, 
+        self.assertEqual(methods,
             ['lookupUserByName', 'initUser', 'initGroup', 'addUser','addGroup',
              'setpassUser', 'lookupGroupByName'])
-        
+
         self.assertEqual(pyanaconda.users.libuser.admin().initUser.call_args_list,
             [((USER,), {})])
-            
+
         self.assertEqual(pyanaconda.users.libuser.admin().initGroup.call_args_list,
             [((USER,), {})])
-        
+
         self.assertEqual(pyanaconda.users.libuser.admin().initUser().method_calls,
-            [('set', (GIDNUMBER, ['']), {}), 
+            [('set', (GIDNUMBER, ['']), {}),
             ('set', (HOMEDIRECTORY, '/home/%s' % USER), {})]
         )
-        
+
         self.assertEqual(pyanaconda.users.libuser.admin().initGroup().method_calls,
             [('get', (GIDNUMBER,), {})])
-        
+
     def check_user_exists_test(self):
-        import pyanaconda.users     
- 
+        import pyanaconda.users
+
         USER = 'TestUser'
- 
+
         usr = pyanaconda.users.Users(self.anaconda)
         self.assertTrue(usr.checkUserExists(USER, root=''))
-        self.assertEqual(pyanaconda.users.libuser.admin().method_calls, 
-            [('lookupUserByName', (USER,), {})])        
-    
+        self.assertEqual(pyanaconda.users.libuser.admin().method_calls,
+            [('lookupUserByName', (USER,), {})])
+
     def get_pass_algo_md5_test(self):
-        import pyanaconda.users      
+        import pyanaconda.users
         usr = pyanaconda.users.Users(self.anaconda)
         self.assertEqual(usr.getPassAlgo(), None)
-        
+
     def set_user_password_test(self):
-        import pyanaconda.users   
-        
+        import pyanaconda.users
+
         USER = 'TestUser'
         PASS = 'abcde'
         CRYPTED = False
         LOCK = False
-           
+
         usr = pyanaconda.users.Users(self.anaconda)
         usr.setUserPassword(USER, PASS, CRYPTED, LOCK)
-        
+
         methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
-        self.assertEqual(methods, 
+        self.assertEqual(methods,
             ['lookupUserByName', 'setpassUser', 'modifyUser'])
-    
+
     def set_root_password_test(self):
-        import pyanaconda.users   
-                  
+        import pyanaconda.users
+
         usr = pyanaconda.users.Users(self.anaconda)
-        usr.setRootPassword()        
+        usr.setRootPassword()
         methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
-        self.assertEqual(methods, 
-            ['lookupUserByName', 'setpassUser', 'modifyUser'])      
-    
+        self.assertEqual(methods,
+            ['lookupUserByName', 'setpassUser', 'modifyUser'])
+
     def writeks_test(self):
-        import pyanaconda.users 
+        import pyanaconda.users
         usr = pyanaconda.users.Users(self.anaconda)
-        
+
         f = self.fs.open('/test_file', 'w')
         usr.writeKS(f)
         f.close()
-        
+
         import re
         self.assertTrue(
             re.match(r"rootpw[ ]+--iscrypted[ ]+.*\n", self.fs['/test_file']))
-        
+
diff --git a/tests/pyanaconda_test/vnc_test.py b/tests/pyanaconda_test/vnc_test.py
index aff597ec5..45b79e273 100644
--- a/tests/pyanaconda_test/vnc_test.py
+++ b/tests/pyanaconda_test/vnc_test.py
@@ -4,24 +4,24 @@ import mock
 import os
 
 class VncTest(mock.TestCase):
-    
+
     def setUp(self):
         self.setupModules(["_isys", "block", "logging", "ConfigParser"])
         self.fs = mock.DiskIO()
-      
+
         import pyanaconda
         pyanaconda.anaconda_log = mock.Mock()
-        
+
         self.OK = 22
-        
+
         import pyanaconda.vnc
         pyanaconda.vnc.log = mock.Mock()
-        pyanaconda.vnc.os = mock.Mock()     
+        pyanaconda.vnc.os = mock.Mock()
         pyanaconda.vnc.subprocess = mock.Mock()
         pyanaconda.vnc.subprocess.Popen().communicate.return_value = (1, 2)
         pyanaconda.vnc.subprocess.Popen().returncode = self.OK
         pyanaconda.vnc.open = self.fs.open
-        
+
         self.ROOT = '/'
         self.DISPLAY = '2'
         self.DESKTOP = 'Desktop'
@@ -30,14 +30,14 @@ class VncTest(mock.TestCase):
         self.PW_INIT_FILE = '/tmp/vncpassword.dat'
         self.PW_FILE = '/tmp/vncpassword'
         self.VNCCONNECTHOST = 'host'
-   
+
     def tearDown(self):
         self.tearDownModules()
 
     def recover_vnc_password_1_test(self):
         import pyanaconda.vnc
-        pyanaconda.vnc.open = mock.Mock(side_effect=Exception())
-        
+        pyanaconda.vnc.open = mock.Mock(side_effect=IOError())
+
         server = pyanaconda.vnc.VncServer()
         server.recoverVNCPassword()
         self.assertEqual(server.password, '')
@@ -45,39 +45,28 @@ class VncTest(mock.TestCase):
     def recover_vnc_password_2_test(self):
         import pyanaconda.vnc
         self.fs.open(self.PW_INIT_FILE, 'w').write('abcdef')
-       
+
         server = pyanaconda.vnc.VncServer(pw_init_file=self.PW_INIT_FILE)
         server.recoverVNCPassword()
         self.assertEqual(server.password, 'abcdef')
 
     def set_vnc_password_1_test(self):
-        import pyanaconda.vnc       
+        import pyanaconda.vnc
         server = pyanaconda.vnc.VncServer()
-        server.setVNCParam = mock.Mock()
-        
+        pyanaconda.vnc.iutil = mock.Mock()
+        pyanaconda.vnc.os.pipe.return_value = (1, 2)
+
         server.setVNCPassword()
-        params = [x[0] for x in server.setVNCParam.call_args_list]
-        self.assertEqual(params, 
-            [('SecurityTypes', 'None'), ('rfbauth', '0')])
-
-    def set_vnc_password_2_test(self):
-        import pyanaconda.vnc       
-        server = pyanaconda.vnc.VncServer(pw_file=self.PW_FILE)
-        server.password = 'abcdef'
-        server.setVNCParam = mock.Mock()
-        
-        ret = server.setVNCPassword()
-        params = [x[0] for x in server.setVNCParam.call_args_list]
-        self.assertEqual(params,
-            [('SecurityTypes', 'VncAuth'), ('rfbauth', self.PW_FILE)])
-        self.assertEqual(ret, self.OK)
+        self.assertEqual(
+            pyanaconda.vnc.iutil.execWithRedirect.call_args_list,
+            [(('vncpasswd', ['-f']), {'stdin': 1, 'stdout': '/tmp/vncpassword'})])
 
     def initialize_test(self):
         import pyanaconda.vnc
-        
+
         IP = '192.168.0.21'
         HOSTNAME = 'desktop'
-        
+
         dev = mock.Mock()
         dev.get.return_value = 'eth0'
         pyanaconda.vnc.network = mock.Mock()
@@ -86,50 +75,38 @@ class VncTest(mock.TestCase):
         pyanaconda.vnc.network.getDefaultHostname.return_value = HOSTNAME
         pyanaconda.vnc.isys = mock.Mock()
         pyanaconda.vnc.isys.getIPAddresses = mock.Mock(return_value=[IP])
-        
+
         server = pyanaconda.vnc.VncServer(display=self.DISPLAY)
         server.initialize()
         expected = "%s:%s (%s)" % (HOSTNAME, self.DISPLAY, IP)
         self.assertEqual(server.connxinfo, expected)
 
-    def set_vnc_param_test(self):
-        import pyanaconda.vnc        
-        PARAM = 'param'
-        VALUE = 'value'
-        
-        server = pyanaconda.vnc.VncServer(display=self.DISPLAY)
-        ret = server.setVNCParam(PARAM, VALUE)
-        self.assertEqual(ret, self.OK)
-        
-        expected = "%s=%s" % (PARAM, VALUE)
-        self.assertTrue(expected in pyanaconda.vnc.subprocess.Popen.call_args[0][0])
-
     def openlogfile_test(self):
         import pyanaconda.vnc
         FILE = 'file'
         pyanaconda.vnc.os.O_RDWR = os.O_RDWR
-        pyanaconda.vnc.os.O_CREAT = os.O_CREAT 
+        pyanaconda.vnc.os.O_CREAT = os.O_CREAT
         pyanaconda.vnc.os.open.return_value = FILE
-        
+
         server = pyanaconda.vnc.VncServer(log_file=self.LOG_FILE)
         ret = server.openlogfile()
         self.assertEqual(ret, FILE)
-        self.assertEqual(pyanaconda.vnc.os.open.call_args, 
+        self.assertEqual(pyanaconda.vnc.os.open.call_args,
             ((self.LOG_FILE, os.O_RDWR | os.O_CREAT), {})
         )
-        
+
     def connect_to_view_test(self):
         import pyanaconda.vnc
         pyanaconda.vnc.subprocess.Popen().communicate.return_value = (self.OK, '')
-        
+
         server = pyanaconda.vnc.VncServer(vncconnecthost=self.VNCCONNECTHOST)
         ret = server.connectToView()
         self.assertTrue(ret)
-        
+
         params = pyanaconda.vnc.subprocess.Popen.call_args[0][0]
         self.assertTrue(self.VNCCONNECTHOST in params)
         self.assertTrue(params[params.index(self.VNCCONNECTHOST)-1] == "-connect")
-        
+
     def start_server_test(self):
         import pyanaconda.vnc
         pyanaconda.vnc.VncServer.initialize = mock.Mock()
@@ -138,15 +115,15 @@ class VncTest(mock.TestCase):
         pyanaconda.vnc.subprocess.Popen().poll.return_value = None
         pyanaconda.vnc.os.environ = {}
         pyanaconda.vnc.time.sleep = mock.Mock()
-        
+
         server = pyanaconda.vnc.VncServer(root=self.ROOT, display=self.DISPLAY,
             desktop=self.DESKTOP, password=self.PASS, vncconnecthost="")
+        server.openlogfile = mock.Mock()
         server.startServer()
-        
+
         params = pyanaconda.vnc.subprocess.Popen.call_args[0][0]
         self.assertTrue('desktop=%s'%self.DESKTOP  in params)
         self.assertTrue(':%s'%self.DISPLAY  in params)
         self.assertTrue(pyanaconda.vnc.VncServer.VNCListen.called)
         self.assertTrue("DISPLAY" in pyanaconda.vnc.os.environ)
         self.assertEqual(pyanaconda.vnc.os.environ['DISPLAY'], ":%s" % self.DISPLAY)
-