[PATCH 1/2] Move tests to old_tests and add some new, working tests

Vratislav Podzimek vpodzime at redhat.com
Tue Jul 16 13:01:40 UTC 2013


Signed-off-by: Vratislav Podzimek <vpodzime at redhat.com>
---
 Makefile.am                                        |   6 +-
 configure.ac                                       |  10 -
 old_tests/Makefile.am                              |  22 +
 old_tests/kickstart_test/Makefile.am               |  22 +
 old_tests/kickstart_test/commands_test.py          |  93 ++++
 old_tests/logpicker_test/Makefile.am               |  30 ++
 .../logpicker_test/archiving_test/Makefile.am      |  28 ++
 .../archiving_test/archivebaseclass_test.py        |  35 ++
 .../archiving_test/bzip2archive_test.py            | 119 +++++
 .../logpicker_test/logmining_test/Makefile.am      |  31 ++
 .../logmining_test/anacondalogminer_test.py        | 125 ++++++
 .../logmining_test/dmsetupinfologminer_test.py     |  19 +
 .../logmining_test/dmsetuplslogminer_test.py       |  19 +
 .../logmining_test/filesystemlogminer_test.py      |  74 ++++
 .../logmining_test/logminerbaseclass_test.py       | 106 +++++
 old_tests/logpicker_test/logpicker_test.py         |  93 ++++
 old_tests/logpicker_test/main_test.py              |  19 +
 old_tests/logpicker_test/sending_test/Makefile.am  |  33 ++
 .../sending_test/bugzillasender_test.py            |  99 +++++
 .../sending_test/emailsender_test.py               | 104 +++++
 .../logpicker_test/sending_test/ftpsender_test.py  | 156 +++++++
 .../sending_test/localsender_test.py               |  46 ++
 .../logpicker_test/sending_test/scpsender_test.py  | 106 +++++
 .../sending_test/senderbaseclass_test.py           |  56 +++
 .../sending_test/stratasender_test.py              |  95 ++++
 old_tests/mock/Makefile.am                         |  21 +
 old_tests/mock/__init__.py                         |  94 ++++
 old_tests/mock/disk.py                             | 128 ++++++
 old_tests/mock/mock.py                             | 271 ++++++++++++
 old_tests/pyanaconda_test/Makefile.am              |  45 ++
 old_tests/pyanaconda_test/backend_test.py          | 227 ++++++++++
 old_tests/pyanaconda_test/bootloader_test.py       |  59 +++
 old_tests/pyanaconda_test/desktop_test.py          | 100 +++++
 old_tests/pyanaconda_test/flags_test.py            | 132 ++++++
 old_tests/pyanaconda_test/image_test.py            | 147 +++++++
 old_tests/pyanaconda_test/indexed_dict_test.py     |  49 +++
 old_tests/pyanaconda_test/iutil_test.py            |  37 ++
 old_tests/pyanaconda_test/network_test.py          | 389 +++++++++++++++++
 old_tests/pyanaconda_test/packages_test.py         |  25 ++
 old_tests/pyanaconda_test/packaging_test.py        | 126 ++++++
 old_tests/pyanaconda_test/partintfhelpers_test.py  | 480 +++++++++++++++++++++
 old_tests/pyanaconda_test/product_test.py          |  82 ++++
 old_tests/pyanaconda_test/rescue_test.py           | 297 +++++++++++++
 old_tests/pyanaconda_test/security_test.py         |  62 +++
 old_tests/pyanaconda_test/simpleconfig_test.py     | 154 +++++++
 old_tests/pyanaconda_test/timezone_test.py         |  56 +++
 old_tests/pyanaconda_test/users_test.py            | 142 ++++++
 old_tests/pyanaconda_test/vnc_test.py              | 116 +++++
 old_tests/pylint/Makefile.am                       |  22 +
 old_tests/pylint/pylint-false-positives            |  34 ++
 old_tests/pylint/runpylint.sh                      | 108 +++++
 old_tests/regex/Makefile.am                        |  22 +
 old_tests/regex/proxy_test.py                      | 112 +++++
 tests/Makefile.am                                  |  22 -
 tests/kickstart_test/Makefile.am                   |  22 -
 tests/kickstart_test/commands_test.py              |  93 ----
 tests/logpicker_test/Makefile.am                   |  30 --
 tests/logpicker_test/archiving_test/Makefile.am    |  28 --
 .../archiving_test/archivebaseclass_test.py        |  35 --
 .../archiving_test/bzip2archive_test.py            | 119 -----
 tests/logpicker_test/logmining_test/Makefile.am    |  31 --
 .../logmining_test/anacondalogminer_test.py        | 125 ------
 .../logmining_test/dmsetupinfologminer_test.py     |  19 -
 .../logmining_test/dmsetuplslogminer_test.py       |  19 -
 .../logmining_test/filesystemlogminer_test.py      |  74 ----
 .../logmining_test/logminerbaseclass_test.py       | 106 -----
 tests/logpicker_test/logpicker_test.py             |  93 ----
 tests/logpicker_test/main_test.py                  |  19 -
 tests/logpicker_test/sending_test/Makefile.am      |  33 --
 .../sending_test/bugzillasender_test.py            |  99 -----
 .../sending_test/emailsender_test.py               | 104 -----
 .../logpicker_test/sending_test/ftpsender_test.py  | 156 -------
 .../sending_test/localsender_test.py               |  46 --
 .../logpicker_test/sending_test/scpsender_test.py  | 106 -----
 .../sending_test/senderbaseclass_test.py           |  56 ---
 .../sending_test/stratasender_test.py              |  95 ----
 tests/mock/Makefile.am                             |  21 -
 tests/mock/__init__.py                             |  94 ----
 tests/mock/disk.py                                 | 128 ------
 tests/mock/mock.py                                 | 271 ------------
 tests/pyanaconda_test/Makefile.am                  |  45 --
 tests/pyanaconda_test/backend_test.py              | 227 ----------
 tests/pyanaconda_test/bootloader_test.py           |  59 ---
 tests/pyanaconda_test/desktop_test.py              | 100 -----
 tests/pyanaconda_test/flags_test.py                | 132 ------
 tests/pyanaconda_test/image_test.py                | 147 -------
 tests/pyanaconda_test/indexed_dict_test.py         |  49 ---
 tests/pyanaconda_test/iutil_test.py                |  37 --
 tests/pyanaconda_test/network_test.py              | 389 -----------------
 tests/pyanaconda_test/packages_test.py             |  25 --
 tests/pyanaconda_test/packaging_test.py            | 126 ------
 tests/pyanaconda_test/partintfhelpers_test.py      | 480 ---------------------
 tests/pyanaconda_test/product_test.py              |  82 ----
 tests/pyanaconda_test/rescue_test.py               | 297 -------------
 tests/pyanaconda_test/security_test.py             |  62 ---
 tests/pyanaconda_test/simpleconfig_test.py         | 154 -------
 tests/pyanaconda_test/timezone_test.py             |  56 ---
 tests/pyanaconda_test/users_test.py                | 142 ------
 tests/pyanaconda_test/vnc_test.py                  | 116 -----
 tests/pyanaconda_tests/localization_test.py        | 109 +++++
 tests/pyanaconda_tests/timezone_test.py            |  73 ++++
 tests/pylint/Makefile.am                           |  22 -
 tests/pylint/pylint-false-positives                |  34 --
 tests/pylint/runpylint.sh                          | 108 -----
 tests/regex/Makefile.am                            |  22 -
 tests/regex/proxy_test.py                          | 112 -----
 106 files changed, 5252 insertions(+), 5080 deletions(-)
 create mode 100644 old_tests/Makefile.am
 create mode 100644 old_tests/kickstart_test/Makefile.am
 create mode 100644 old_tests/kickstart_test/commands_test.py
 create mode 100644 old_tests/logpicker_test/Makefile.am
 create mode 100644 old_tests/logpicker_test/archiving_test/Makefile.am
 create mode 100644 old_tests/logpicker_test/archiving_test/archivebaseclass_test.py
 create mode 100644 old_tests/logpicker_test/archiving_test/bzip2archive_test.py
 create mode 100644 old_tests/logpicker_test/logmining_test/Makefile.am
 create mode 100644 old_tests/logpicker_test/logmining_test/anacondalogminer_test.py
 create mode 100644 old_tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
 create mode 100644 old_tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
 create mode 100644 old_tests/logpicker_test/logmining_test/filesystemlogminer_test.py
 create mode 100644 old_tests/logpicker_test/logmining_test/logminerbaseclass_test.py
 create mode 100644 old_tests/logpicker_test/logpicker_test.py
 create mode 100644 old_tests/logpicker_test/main_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/Makefile.am
 create mode 100644 old_tests/logpicker_test/sending_test/bugzillasender_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/emailsender_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/ftpsender_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/localsender_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/scpsender_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/senderbaseclass_test.py
 create mode 100644 old_tests/logpicker_test/sending_test/stratasender_test.py
 create mode 100644 old_tests/mock/Makefile.am
 create mode 100644 old_tests/mock/__init__.py
 create mode 100644 old_tests/mock/disk.py
 create mode 100644 old_tests/mock/mock.py
 create mode 100644 old_tests/pyanaconda_test/Makefile.am
 create mode 100644 old_tests/pyanaconda_test/backend_test.py
 create mode 100644 old_tests/pyanaconda_test/bootloader_test.py
 create mode 100644 old_tests/pyanaconda_test/desktop_test.py
 create mode 100644 old_tests/pyanaconda_test/flags_test.py
 create mode 100644 old_tests/pyanaconda_test/image_test.py
 create mode 100644 old_tests/pyanaconda_test/indexed_dict_test.py
 create mode 100644 old_tests/pyanaconda_test/iutil_test.py
 create mode 100644 old_tests/pyanaconda_test/network_test.py
 create mode 100644 old_tests/pyanaconda_test/packages_test.py
 create mode 100644 old_tests/pyanaconda_test/packaging_test.py
 create mode 100644 old_tests/pyanaconda_test/partintfhelpers_test.py
 create mode 100644 old_tests/pyanaconda_test/product_test.py
 create mode 100644 old_tests/pyanaconda_test/rescue_test.py
 create mode 100644 old_tests/pyanaconda_test/security_test.py
 create mode 100644 old_tests/pyanaconda_test/simpleconfig_test.py
 create mode 100644 old_tests/pyanaconda_test/timezone_test.py
 create mode 100644 old_tests/pyanaconda_test/users_test.py
 create mode 100644 old_tests/pyanaconda_test/vnc_test.py
 create mode 100644 old_tests/pylint/Makefile.am
 create mode 100644 old_tests/pylint/pylint-false-positives
 create mode 100755 old_tests/pylint/runpylint.sh
 create mode 100644 old_tests/regex/Makefile.am
 create mode 100644 old_tests/regex/__init__.py
 create mode 100755 old_tests/regex/proxy_test.py
 delete mode 100644 tests/Makefile.am
 delete mode 100644 tests/kickstart_test/Makefile.am
 delete mode 100644 tests/kickstart_test/commands_test.py
 delete mode 100644 tests/logpicker_test/Makefile.am
 delete mode 100644 tests/logpicker_test/archiving_test/Makefile.am
 delete mode 100644 tests/logpicker_test/archiving_test/archivebaseclass_test.py
 delete mode 100644 tests/logpicker_test/archiving_test/bzip2archive_test.py
 delete mode 100644 tests/logpicker_test/logmining_test/Makefile.am
 delete mode 100644 tests/logpicker_test/logmining_test/anacondalogminer_test.py
 delete mode 100644 tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
 delete mode 100644 tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
 delete mode 100644 tests/logpicker_test/logmining_test/filesystemlogminer_test.py
 delete mode 100644 tests/logpicker_test/logmining_test/logminerbaseclass_test.py
 delete mode 100644 tests/logpicker_test/logpicker_test.py
 delete mode 100644 tests/logpicker_test/main_test.py
 delete mode 100644 tests/logpicker_test/sending_test/Makefile.am
 delete mode 100644 tests/logpicker_test/sending_test/bugzillasender_test.py
 delete mode 100644 tests/logpicker_test/sending_test/emailsender_test.py
 delete mode 100644 tests/logpicker_test/sending_test/ftpsender_test.py
 delete mode 100644 tests/logpicker_test/sending_test/localsender_test.py
 delete mode 100644 tests/logpicker_test/sending_test/scpsender_test.py
 delete mode 100644 tests/logpicker_test/sending_test/senderbaseclass_test.py
 delete mode 100644 tests/logpicker_test/sending_test/stratasender_test.py
 delete mode 100644 tests/mock/Makefile.am
 delete mode 100644 tests/mock/__init__.py
 delete mode 100644 tests/mock/disk.py
 delete mode 100644 tests/mock/mock.py
 delete mode 100644 tests/pyanaconda_test/Makefile.am
 delete mode 100644 tests/pyanaconda_test/backend_test.py
 delete mode 100644 tests/pyanaconda_test/bootloader_test.py
 delete mode 100644 tests/pyanaconda_test/desktop_test.py
 delete mode 100644 tests/pyanaconda_test/flags_test.py
 delete mode 100644 tests/pyanaconda_test/image_test.py
 delete mode 100644 tests/pyanaconda_test/indexed_dict_test.py
 delete mode 100644 tests/pyanaconda_test/iutil_test.py
 delete mode 100644 tests/pyanaconda_test/network_test.py
 delete mode 100644 tests/pyanaconda_test/packages_test.py
 delete mode 100644 tests/pyanaconda_test/packaging_test.py
 delete mode 100644 tests/pyanaconda_test/partintfhelpers_test.py
 delete mode 100644 tests/pyanaconda_test/product_test.py
 delete mode 100644 tests/pyanaconda_test/rescue_test.py
 delete mode 100644 tests/pyanaconda_test/security_test.py
 delete mode 100644 tests/pyanaconda_test/simpleconfig_test.py
 delete mode 100644 tests/pyanaconda_test/timezone_test.py
 delete mode 100644 tests/pyanaconda_test/users_test.py
 delete mode 100644 tests/pyanaconda_test/vnc_test.py
 create mode 100644 tests/pyanaconda_tests/localization_test.py
 create mode 100644 tests/pyanaconda_tests/timezone_test.py
 delete mode 100644 tests/pylint/Makefile.am
 delete mode 100644 tests/pylint/pylint-false-positives
 delete mode 100755 tests/pylint/runpylint.sh
 delete mode 100644 tests/regex/Makefile.am
 delete mode 100644 tests/regex/__init__.py
 delete mode 100755 tests/regex/proxy_test.py

diff --git a/Makefile.am b/Makefile.am
index 3ae7825..c4c3c0a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -20,7 +20,7 @@
 ACLOCAL_AMFLAGS = -I m4
 
 SUBDIRS = pyanaconda po data \
-	  tests utils scripts docs dracut widgets
+	      utils scripts docs dracut widgets
 
 EXTRA_DIST = config.rpath COPYING \
              anaconda.spec.in
@@ -116,10 +116,10 @@ updates:
 
 # UNIT TESTING TARGETS
 unittest:
-	PYTHONPATH=tests/:. nosetests --exclude=logpicker -a \!acceptance,\!slow  tests/
+	PYTHONPATH=tests/:. nosetests -v --exclude=logpicker -a \!acceptance,\!slow  tests/
 
 unittests-logpicker:
-	PYTHONPATH=tests/:.:utils/ nosetests tests/logpicker_test
+	PYTHONPATH=tests/:.:utils/ nosetests -v old_tests/logpicker_test
 
 # GUI TESTING
 runspoke:
diff --git a/configure.ac b/configure.ac
index 606d6e4..4b7c34d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -242,16 +242,6 @@ AC_CONFIG_FILES([Makefile
                  pyanaconda/ui/tui/spokes/Makefile
                  pyanaconda/ui/tui/tools/Makefile
                  pyanaconda/ui/tui/Makefile
-                 tests/Makefile
-                 tests/mock/Makefile
-                 tests/kickstart_test/Makefile
-                 tests/pylint/Makefile
-                 tests/regex/Makefile
-                 tests/pyanaconda_test/Makefile
-                 tests/logpicker_test/Makefile
-                 tests/logpicker_test/sending_test/Makefile
-                 tests/logpicker_test/archiving_test/Makefile
-                 tests/logpicker_test/logmining_test/Makefile
                  data/post-scripts/Makefile
                  utils/Makefile
                  utils/log_picker/Makefile
diff --git a/old_tests/Makefile.am b/old_tests/Makefile.am
new file mode 100644
index 0000000..cb4c701
--- /dev/null
+++ b/old_tests/Makefile.am
@@ -0,0 +1,22 @@
+# tests/Makefile.am for anaconda
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: David Cantrell <dcantrell at redhat.com>
+
+SUBDIRS = mock kickstart_test regex pyanaconda_test pylint logpicker_test
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/old_tests/kickstart_test/Makefile.am b/old_tests/kickstart_test/Makefile.am
new file mode 100644
index 0000000..20b7a14
--- /dev/null
+++ b/old_tests/kickstart_test/Makefile.am
@@ -0,0 +1,22 @@
+# tests/kickstart/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Chris Lumens <clumens at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/old_tests/kickstart_test/commands_test.py b/old_tests/kickstart_test/commands_test.py
new file mode 100644
index 0000000..feb7132
--- /dev/null
+++ b/old_tests/kickstart_test/commands_test.py
@@ -0,0 +1,93 @@
+#!/usr/bin/python
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Chris Lumens <clumens at redhat.com>
+import unittest
+import sys
+from mock import Mock, patch, TestCase, acceptance
+
+class O(object):
+    pass
+
+# Verify that each kickstart command in anaconda uses the correct version of
+# that command as provided by pykickstart.  That is, if there's an FC3 and an
+# F10 version of a command, make sure anaconda >= F10 uses the F10 version.
+class CommandVersionTestCase(TestCase):
+    def setUp(self):
+        self.setupModules([
+            'pyanaconda.isys',
+            'pyanaconda.storage',
+            'pyanaconda.storage.isys',
+            'pyanaconda.storage.devices',
+            'pyanaconda.storage.formats',
+            'pyanaconda.storage.partitioning',
+            'pyanaconda.storage.deviceaction',
+            'pyanaconda.storage.devicelibs',
+            'pyanaconda.storage.devicelibs.lvm',
+            'pyanaconda.storage.iscsi',
+            'pyanaconda.storage.fcoe',
+            'pyanaconda.storage.udev',
+            'pyanaconda.storage.zfcp',
+            'iutil',
+            'constants',
+            'flags',
+            'anaconda_log',
+            'parted',
+            'block'])
+
+        import pyanaconda.anaconda_log
+        pyanaconda.anaconda_log.init()
+
+        from pyanaconda import kickstart
+        import pykickstart.version
+
+        self.handler = pykickstart.version.makeVersion(kickstart.ver)
+
+    def tearDown(self):
+        self.tearDownModules()
+
+
+    @acceptance
+    def commands_test(self):
+        for (commandName, commandObj) in kickstart.commandMap.iteritems():
+            baseClass = commandObj().__class__.__bases__[0]
+            pykickstartClass = self.handler.commands[commandName].__class__
+            self.assertEqual(baseClass.__name__, pykickstartClass.__name__)
+
+# Do the same thing as CommandVersionTestCase, but for data objects.
+class DataVersionTestCase(TestCase):
+    def setUp(self):
+        import pyanaconda.anaconda_log
+        pyanaconda.anaconda_log.init()
+
+        from pyanaconda import kickstart
+        import pykickstart.version
+
+        self.handler = pykickstart.version.makeVersion(kickstart.ver)
+
+    @acceptance
+    def data_test(self):
+        for (dataName, dataObj) in kickstart.dataMap.iteritems():
+            baseClass = dataObj().__class__.__bases__[0]
+
+            # pykickstart does not expose data objects a mapping the way it
+            # does command objects.
+            pykickstartClass = eval("self.handler.%s" % dataName)
+
+            self.assertEqual(baseClass.__name__, pykickstartClass.__name__)
+
+
diff --git a/old_tests/logpicker_test/Makefile.am b/old_tests/logpicker_test/Makefile.am
new file mode 100644
index 0000000..0671b2f
--- /dev/null
+++ b/old_tests/logpicker_test/Makefile.am
@@ -0,0 +1,30 @@
+# tests/logpicker_test/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Tomas Mlcoch <tmlcoch at redhat.com>
+
+SUBDIRS = archiving_test logmining_test sending_test
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
+
+ANACDIR = $(top_builddir)/pyanaconda
+TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
+
+TESTS = logpicker_test.py \
+    main_test.py
diff --git a/old_tests/logpicker_test/archiving_test/Makefile.am b/old_tests/logpicker_test/archiving_test/Makefile.am
new file mode 100644
index 0000000..481672c
--- /dev/null
+++ b/old_tests/logpicker_test/archiving_test/Makefile.am
@@ -0,0 +1,28 @@
+# tests/logpicker_test/archiving_test/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Tomas Mlcoch <tmlcoch at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
+
+ANACDIR = $(top_builddir)/pyanaconda
+TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
+
+TESTS = archivebaseclass_test.py \
+    bzip2archive_test.py
diff --git a/old_tests/logpicker_test/archiving_test/archivebaseclass_test.py b/old_tests/logpicker_test/archiving_test/archivebaseclass_test.py
new file mode 100644
index 0000000..2f4f0e6
--- /dev/null
+++ b/old_tests/logpicker_test/archiving_test/archivebaseclass_test.py
@@ -0,0 +1,35 @@
+import mock
+
+class ArchiveBaseClassTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def create_tmp_tar_test(self):
+        import log_picker.archiving as archiving
+               
+        FILE1 = "/tmp/abcd/file1"
+        FILE2 = "/tmp/abcd/file2"
+        FILELIST = [FILE1, FILE2]
+        TMPFILE = "/tmp/tmpfile.tar"
+        
+        archiving.tempfile = mock.Mock()
+        archiving.tempfile.mkstemp.return_value = "", TMPFILE
+        archiving.tarfile = mock.Mock()
+        
+        self.fs.open(FILE1, 'w').write('1\n')
+        self.fs.open(FILE2, 'w').write('2\n')
+        self.fs.open(TMPFILE, 'w')
+        
+        obj = archiving.ArchiveBaseClass()
+        ret = obj._create_tmp_tar(FILELIST)
+        
+        self.assertEqual(TMPFILE, ret)
+        self.assertEqual(archiving.tarfile.open().add.call_args_list, 
+            [((FILE1,), {'arcname': 'abcd/file1'}), 
+             ((FILE2,), {'arcname': 'abcd/file2'})]
+         )
+
diff --git a/old_tests/logpicker_test/archiving_test/bzip2archive_test.py b/old_tests/logpicker_test/archiving_test/bzip2archive_test.py
new file mode 100644
index 0000000..aa01e95
--- /dev/null
+++ b/old_tests/logpicker_test/archiving_test/bzip2archive_test.py
@@ -0,0 +1,119 @@
+import os
+import mock
+import tempfile
+from log_picker.archiving import ArchivationError
+
+
+class Bzip2ArchiveTest(mock.TestCase):
+    def setUp(self):
+        self.tmp_files = []
+        pass
+    
+    def _get_tmp(self):
+        _, filename = tempfile.mkstemp()
+        self.tmp_files.append(filename)
+        return filename
+    
+    def tearDown(self):
+        for file in self.tmp_files:
+            os.unlink(file)
+    
+    def mimetype_test(self):
+        from log_picker.archiving import Bzip2Archive
+        obj = Bzip2Archive(usetar=True)
+        ret = obj.mimetype
+        self.assertEqual(ret, 'application/x-bzip2')
+    
+    def support_compression_test(self):
+        from log_picker.archiving import Bzip2Archive
+        obj = Bzip2Archive(usetar=True)
+        ret = obj.support_compression
+        self.assertTrue(ret)
+    
+    def file_ext_1_test(self):
+        from log_picker.archiving import Bzip2Archive
+        obj = Bzip2Archive(usetar=True)
+        ret = obj.file_ext
+        self.assertEqual(ret, '.tar.bz2')
+    
+    def file_ext_2_test(self):
+        from log_picker.archiving import Bzip2Archive
+        obj = Bzip2Archive(usetar=False)
+        ret = obj.file_ext
+        self.assertEqual(ret, '.bz2')
+    
+    def create_archive_1_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        infile1 = self._get_tmp()
+        infile2 = self._get_tmp()
+        
+        obj = Bzip2Archive(usetar=False)
+        self.assertRaises(ArchivationError, obj.create_archive, out_filename, \
+                            [infile1, infile2])
+        
+    def create_archive_2_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        
+        obj = Bzip2Archive(usetar=False)
+        self.assertRaises(ArchivationError, obj.create_archive, out_filename, [])
+
+    def create_archive_3_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        
+        obj = Bzip2Archive(usetar=True)
+        self.assertRaises(ArchivationError, obj.create_archive, out_filename, [])
+    
+    def create_archive_4_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        infile1 = self._get_tmp()
+        infile2 = self._get_tmp()
+        
+        obj = Bzip2Archive(usetar=True)
+        # Because both files (infile1 and infile2) are empty
+        self.assertRaises(ArchivationError, obj.create_archive, out_filename, 
+                            [infile1, infile2])
+
+    def create_archive_5_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        infile1 = self._get_tmp()
+        infile2 = self._get_tmp()
+        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
+        open(infile2, 'w').write('1234567890')
+        
+        obj = Bzip2Archive(usetar=True)
+        obj.create_archive(out_filename, [infile1, infile2])
+        self.assertTrue(os.path.getsize(out_filename))
+    
+    def create_archive_6_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        infile1 = self._get_tmp()
+        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
+        
+        obj = Bzip2Archive(usetar=False)
+        obj.create_archive(out_filename, [infile1])
+        self.assertTrue(os.path.getsize(out_filename))
+    
+    def create_archive_7_test(self):
+        from log_picker.archiving import Bzip2Archive
+        
+        out_filename = self._get_tmp()
+        infile1 = self._get_tmp()
+        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
+        
+        obj = Bzip2Archive(usetar=True)
+        obj.create_archive(out_filename, [infile1])
+        self.assertTrue(os.path.getsize(out_filename))
+        
+    
diff --git a/old_tests/logpicker_test/logmining_test/Makefile.am b/old_tests/logpicker_test/logmining_test/Makefile.am
new file mode 100644
index 0000000..4c6dfaa
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/Makefile.am
@@ -0,0 +1,31 @@
+# tests/logpicker_test/logmining_test/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Tomas Mlcoch <tmlcoch at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
+
+ANACDIR = $(top_builddir)/pyanaconda
+TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
+
+TESTS = anacondalogminer_test.py \
+    dmsetupinfologminer_test.py \
+    dmsetuplslogminer_test.py \
+    filesystemlogminer_test.py \
+    logminerbaseclass_test.py
diff --git a/old_tests/logpicker_test/logmining_test/anacondalogminer_test.py b/old_tests/logpicker_test/logmining_test/anacondalogminer_test.py
new file mode 100644
index 0000000..22cd1c3
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/anacondalogminer_test.py
@@ -0,0 +1,125 @@
+import mock
+
+class AnacondaLogMinerTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def action_test(self):
+        import log_picker.logmining as logmining
+        
+        ANACONDA_LOG = "anaconda-tb-log"
+        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
+        LOG_CONTENT = "Test content\n"
+        
+        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
+        
+        logmining.os = mock.Mock()
+        listdir_values = [[ANACONDA_LOG], []]
+        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
+        
+        logmining.open = self.fs.open
+        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
+        
+        proc_mock = mock.Mock()
+        proc_mock.returncode = 0
+        logmining.subprocess = mock.Mock()
+        logmining.subprocess.Popen.return_value = proc_mock
+        
+        logmining.time = mock.Mock()
+        
+        OUTFILE = '/tmp/outfile'
+        f = self.fs.open(OUTFILE, 'w')
+        
+        obj = logmining.AnacondaLogMiner(f)
+        obj._action()
+        f.close()
+        
+        self.assertEqual(self.fs[OUTFILE],
+                            "%s:\n%s\n" % (ANACONDA_LOG_PATH, LOG_CONTENT))
+    
+    def action_raise_1_test(self):
+        import log_picker.logmining as logmining
+        
+        logmining.os = mock.Mock()
+        listdir_values = [[]]
+        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
+        
+        logmining.open = self.fs.open
+        
+        obj = logmining.AnacondaLogMiner()
+        self.assertRaises(logmining.LogMinerError, obj._action)
+    
+    def action_raise_2_test(self):
+        import log_picker.logmining as logmining
+              
+        logmining.os = mock.Mock()
+        listdir_values = [[]]
+        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
+        
+        logmining.open = self.fs.open
+        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
+        
+        proc_mock = mock.Mock()
+        proc_mock.returncode = 1
+        logmining.subprocess = mock.Mock()
+        logmining.subprocess.Popen.return_value = proc_mock
+                
+        obj = logmining.AnacondaLogMiner()
+        self.assertRaises(logmining.LogMinerError, obj._action)
+    
+    def action_raise_3_test(self):
+        import log_picker.logmining as logmining
+        
+        ANACONDA_LOG = "anaconda-tb-log"
+        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
+        LOG_CONTENT = "Test content\n"
+        
+        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
+        
+        logmining.os = mock.Mock()
+        listdir_values = [[], []]
+        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
+        
+        logmining.open = self.fs.open
+        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
+        
+        proc_mock = mock.Mock()
+        proc_mock.returncode = 0
+        logmining.subprocess = mock.Mock()
+        logmining.subprocess.Popen.return_value = proc_mock
+        
+        logmining.time = mock.Mock()
+        
+        obj = logmining.AnacondaLogMiner()
+        self.assertRaises(logmining.LogMinerError, obj._action)
+
+    def action_raise_4_test(self):
+        import log_picker.logmining as logmining
+        
+        ANACONDA_LOG = "different-log"
+        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
+        LOG_CONTENT = "Test content\n"
+        
+        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
+        
+        logmining.os = mock.Mock()
+        listdir_values = [[ANACONDA_LOG], []]
+        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
+        
+        logmining.open = self.fs.open
+        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
+        
+        proc_mock = mock.Mock()
+        proc_mock.returncode = 0
+        logmining.subprocess = mock.Mock()
+        logmining.subprocess.Popen.return_value = proc_mock
+        
+        logmining.time = mock.Mock()
+               
+        obj = logmining.AnacondaLogMiner()
+        self.assertRaises(logmining.LogMinerError, obj._action)
+        
diff --git a/old_tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py b/old_tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
new file mode 100644
index 0000000..9aa3c81
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
@@ -0,0 +1,19 @@
+import mock
+
+class DmSetupInfoLogMinerTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def action_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.DmSetupInfoLogMiner()
+        obj._run_command = mock.Mock()
+        obj._action()
+        
+        self.assertTrue(obj._run_command.called)
+
diff --git a/old_tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py b/old_tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
new file mode 100644
index 0000000..c0d4bc4
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
@@ -0,0 +1,19 @@
+import mock
+
+class DmSetupLsLogMinerTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def action_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.DmSetupLsLogMiner()
+        obj._run_command = mock.Mock()
+        obj._action()
+        
+        self.assertTrue(obj._run_command.called)
+
diff --git a/old_tests/logpicker_test/logmining_test/filesystemlogminer_test.py b/old_tests/logpicker_test/logmining_test/filesystemlogminer_test.py
new file mode 100644
index 0000000..a9d9836
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/filesystemlogminer_test.py
@@ -0,0 +1,74 @@
+import mock
+
+class FileSystemLogMinerTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def size_conversion_1_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(24)
+        self.assertEqual(size, 24)
+        self.assertEqual(unit, "")
+    
+    def size_conversion_2_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(2400)
+        self.assertEqual(size, 2.3)
+        self.assertEqual(unit, "K")
+    
+    def size_conversion_3_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(1024)
+        self.assertEqual(size, 1)
+        self.assertEqual(unit, "K")
+    
+    def size_conversion_4_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(1048576)
+        self.assertEqual(size, 1)
+        self.assertEqual(unit, "M")
+    
+    def size_conversion_5_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(1160576)
+        self.assertEqual(size, 1.1)
+        self.assertEqual(unit, "M")
+    
+    def size_conversion_6_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(1073741824)
+        self.assertEqual(size, 1)
+        self.assertEqual(unit, "G")
+    
+    def size_conversion_7_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(1273741824)
+        self.assertEqual(size, 1.2)
+        self.assertEqual(unit, "G")
+    
+    def size_conversion_8_test(self):
+        import log_picker.logmining as logmining
+        
+        obj = logmining.FileSystemLogMiner()
+        size, unit = obj._size_conversion(0)
+        self.assertEqual(size, 0)
+        self.assertEqual(unit, "")
+
diff --git a/old_tests/logpicker_test/logmining_test/logminerbaseclass_test.py b/old_tests/logpicker_test/logmining_test/logminerbaseclass_test.py
new file mode 100644
index 0000000..aad9af8
--- /dev/null
+++ b/old_tests/logpicker_test/logmining_test/logminerbaseclass_test.py
@@ -0,0 +1,106 @@
+import mock
+
+class LogminingBaseClassTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def get_filename_test(self):
+        from log_picker.logmining import LogMinerBaseClass
+        
+        ret = LogMinerBaseClass.get_filename()
+        self.assertEqual(ret, LogMinerBaseClass._filename)
+    
+    def get_description_test(self):
+        from log_picker.logmining import LogMinerBaseClass
+        
+        ret = LogMinerBaseClass.get_description()
+        self.assertEqual(ret, LogMinerBaseClass._description)
+    
+    def set_logfile_test(self):
+        from log_picker.logmining import LogMinerBaseClass
+        
+        FILENAME = "file123"
+        
+        obj = LogMinerBaseClass()
+        obj.set_logfile(FILENAME)
+        self.assertEqual(FILENAME, obj.logfile)
+       
+    def write_separator_test(self):
+        import log_picker.logmining as logmining
+        logmining.open = self.fs.open
+        
+        OUTFILE = '/tmp/logfile'
+        f = self.fs.open(OUTFILE, 'w')
+        
+        obj = logmining.LogMinerBaseClass(f)
+        obj._write_separator()
+        f.close()
+        
+        self.assertEqual(self.fs[OUTFILE], '\n\n')
+    
+    def write_files_1_test(self):
+        import log_picker.logmining as logmining
+        logmining.open = self.fs.open
+        
+        FILE = '/tmp/infile'
+        CONTENT = "some_random_456_content\n"
+        self.fs.open(FILE, 'w').write(CONTENT)
+        
+        OUTFILE = '/tmp/logfile'
+        f = self.fs.open(OUTFILE, 'w')
+        
+        obj = logmining.LogMinerBaseClass(f)
+        obj._write_files(FILE)
+        f.close()
+               
+        self.assertEqual('%s:\n%s\n' % (FILE, CONTENT), self.fs[OUTFILE])
+        
+    def write_files_2_test(self):
+        import log_picker.logmining as logmining
+        logmining.open = self.fs.open
+        
+        FILE_1 = '/tmp/infile1'
+        FILE_2 = '/tmp/infile2'
+        CONTENT_1 = "some_random_456_content\n"
+        CONTENT_2 = "next_line_789\n"
+        self.fs.open(FILE_1, 'w').write(CONTENT_1)
+        self.fs.open(FILE_2, 'w').write(CONTENT_2)
+        
+        OUTFILE = '/tmp/logfile'
+        f = self.fs.open(OUTFILE, 'w')
+        
+        obj = logmining.LogMinerBaseClass(f)
+        obj._write_files([FILE_1, FILE_2])
+        f.close()
+               
+        self.assertEqual('%s:\n%s\n%s:\n%s\n' % \
+                (FILE_1, CONTENT_1, FILE_2, CONTENT_2), self.fs[OUTFILE])
+    
+    def run_command_test(self):
+        import log_picker.logmining as logmining
+               
+        COMMAND = "some_command param1 param2"
+        STDOUT = "some output"
+        STDERR = "some error"
+        RETCODE = 1
+        
+        proc_mock = mock.Mock()
+        proc_mock.returncode = RETCODE
+        proc_mock.communicate.return_value = (STDOUT, STDERR)
+        logmining.subprocess = mock.Mock()
+        logmining.subprocess.Popen.return_value = proc_mock
+        
+        OUTFILE = "/tmp/outfile"
+        f = self.fs.open(OUTFILE, 'w')
+        
+        obj = logmining.LogMinerBaseClass(f)
+        obj._run_command(COMMAND)
+        f.close()
+        
+        self.assertEqual(self.fs[OUTFILE],
+                "STDOUT:\nsome output\nSTDERR:\nsome error\nRETURN CODE: 1\n")
+
diff --git a/old_tests/logpicker_test/logpicker_test.py b/old_tests/logpicker_test/logpicker_test.py
new file mode 100644
index 0000000..a62d63d
--- /dev/null
+++ b/old_tests/logpicker_test/logpicker_test.py
@@ -0,0 +1,93 @@
+import os
+import sys
+import mock
+
+
+class LogPickerTest(mock.TestCase):
+    def setUp(self):
+        pass
+
+    def getlogs_1_test(self):
+        from log_picker import LogPicker
+
+        miner = mock.Mock()
+        
+        obj = LogPicker(miners=[miner], use_one_file=True)
+        obj.getlogs()
+        
+        self.assertTrue(miner.set_logfile.called)
+        self.assertTrue(miner.getlog.called)
+    
+    def getlogs_2_test(self):
+        from log_picker import LogPicker
+        from log_picker.logmining import LogMinerError
+        
+        miner = mock.Mock()
+        miner.getlog.side_effect = LogMinerError('Just a test')
+        
+        obj = LogPicker(miners=[miner], use_one_file=True)
+        # Temporary redirect stderr output
+        sys.stderr, backup = mock.Mock(), sys.stderr
+        obj.getlogs()
+        sys.stderr = backup
+        
+        self.assertTrue(True)
+        
+    def send_1_test(self):
+        from log_picker import LogPicker
+        
+        sender = mock.Mock()
+        
+        obj = LogPicker(sender_obj=sender)
+        obj.files = ["file"]
+        obj.send()
+        
+        self.assertTrue(sender.sendfile.called)
+        self.assertEqual(sender.sendfile.call_args, 
+                                        (('file', 'text/plain'), {}))
+
+    def send_2_test(self):
+        from log_picker import LogPicker
+        
+        sender = mock.Mock()
+        archiver = mock.Mock()
+        archiver.mimetype = "application/anything"
+        
+        obj = LogPicker(sender_obj=sender, archive_obj=archiver)
+        obj.files = ["file"]
+        obj.archive = "file2"
+        obj.send()
+        
+        self.assertTrue(sender.sendfile.called)
+        self.assertEqual(sender.sendfile.call_args, 
+                                        (('file2', 'application/anything'), {}))
+
+    def create_archive_1_test(self):
+        from log_picker import LogPicker
+        
+        archiver = mock.Mock()
+        archiver.file_ext = ".zip"
+                
+        obj = LogPicker(archive_obj=archiver)
+        obj.create_archive()
+        
+        self.assertTrue(archiver.create_archive.called)
+    
+    def get_tmp_file_test(self):
+        from log_picker import LogPicker
+        
+        obj = LogPicker()
+        ret = obj._get_tmp_file("name")
+        self.assertTrue(os.path.isfile(ret))
+    
+    def errprint_test(self):
+        from log_picker import LogPicker
+        
+        obj = LogPicker()
+        # Temporary redirect stderr output
+        sys.stderr, backup = mock.Mock(), sys.stderr
+        obj._errprint("message")
+        res, sys.stderr = sys.stderr, backup
+        self.assertTrue(res.write.called)
+        self.assertEqual(res.write.call_args[0][0], 'message\n')
+        
diff --git a/old_tests/logpicker_test/main_test.py b/old_tests/logpicker_test/main_test.py
new file mode 100644
index 0000000..0c53dde
--- /dev/null
+++ b/old_tests/logpicker_test/main_test.py
@@ -0,0 +1,19 @@
+#import mock
+
+#
+# Cannot be used, because main file "logpicker" doesn't have ".py" 
+# extension ( => logpicker cannot be imported)
+#
+
+
+#class LogPickerMainTest(mock.TestCase):
+#    def setUp(self):
+#        pass
+#    
+#    def injector_injectarchivator_test(self):
+#        import logpicker
+#        import log_picker.archiving as archiving
+#        
+#        ret = logpicker.Injector.injectArchivator(mock.Mock())
+#        self.assertEqual(ret, archiving.Bzip2Archive)
+
diff --git a/old_tests/logpicker_test/sending_test/Makefile.am b/old_tests/logpicker_test/sending_test/Makefile.am
new file mode 100644
index 0000000..6c944a6
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/Makefile.am
@@ -0,0 +1,33 @@
+# tests/logpicker_test/sending_test/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Tomas Mlcoch <tmlcoch at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
+
+ANACDIR = $(top_builddir)/pyanaconda
+TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
+
+TESTS = bugzillasender_test.py \
+    emailsender_test.py \
+    ftpsender_test.py \
+    localsender_test.py \
+    scpsender_test.py \
+    senderbaseclass_test.py \
+    stratasender_test.py
diff --git a/old_tests/logpicker_test/sending_test/bugzillasender_test.py b/old_tests/logpicker_test/sending_test/bugzillasender_test.py
new file mode 100644
index 0000000..03b07f3
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/bugzillasender_test.py
@@ -0,0 +1,99 @@
+import mock
+
+class BugzillaBaseClassTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(['report.plugins.bugzilla', 
+                            'report.plugins.bugzilla.filer'])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def connect_and_login_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        bugzillasender.filer = mock.Mock()
+        
+        USERNAME = "user"
+        PASSWORD = "foopassword"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        obj.connect_and_login(USERNAME, PASSWORD)
+        
+        self.assertTrue(bugzillasender.filer.BugzillaFiler().login.called)
+        self.assertEqual(bugzillasender.filer.BugzillaFiler().login.call_args,
+                            (('user', 'foopassword'), {}))
+    
+    def connect_and_login_fail_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        bugzillasender.filer = mock.Mock()
+        bugzillasender.filer.BugzillaFiler().login.side_effect = \
+                                        bugzillasender.LoginError('foo', 'bar')
+        
+        USERNAME = "user"
+        PASSWORD = "foopassword"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        self.assertRaises(bugzillasender.SenderError, obj.connect_and_login, \
+                                                            USERNAME, PASSWORD)
+        self.assertTrue(bugzillasender.filer.BugzillaFiler().login.called)
+        self.assertEqual(bugzillasender.filer.BugzillaFiler().login.call_args,
+                            (('user', 'foopassword'), {}))
+    
+    def set_bug_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        BUGID = "123456789"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        obj.set_bug(BUGID)
+        
+        self.assertEqual(BUGID, obj.bug_id)
+    
+    def set_comment_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        COMMENT = "some comment"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        obj.set_comment(COMMENT)
+        
+        self.assertEqual(COMMENT, obj.comment)
+    
+    def sendfile_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        bugzillasender.os = mock.Mock()
+        bugzillasender.os.path = mock.Mock()
+        bugzillasender.os.path.basename = lambda x: x
+        
+        FILE = "/tmp/somefile"
+        MIMETYPE = "text/plain"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        obj._get_description = mock.Mock()
+        obj.bzfiler = mock.Mock()
+        obj.sendfile(FILE, MIMETYPE)
+        
+        self.assertTrue(obj._get_description.called)
+        self.assertTrue(obj.bzfiler.getbug.called)
+        self.assertTrue(obj.bzfiler.getbug().attachfile.called)
+    
+    def sendfile_raise_test(self):
+        import log_picker.sending.bugzillasender as bugzillasender
+        
+        bugzillasender.os = mock.Mock()
+        bugzillasender.os.path = mock.Mock()
+        bugzillasender.os.path.basename = lambda x: x
+        
+        FILE = "/tmp/somefile"
+        MIMETYPE = "text/plain"
+        
+        obj = bugzillasender.BugzillaBaseClass()
+        obj._get_description = mock.Mock()
+        obj.bzfiler = mock.Mock()
+        obj.bzfiler.getbug.side_effect = ValueError('Test exception')
+        
+        self.assertRaises(bugzillasender.SenderError, obj.sendfile, FILE, MIMETYPE)
+
diff --git a/old_tests/logpicker_test/sending_test/emailsender_test.py b/old_tests/logpicker_test/sending_test/emailsender_test.py
new file mode 100644
index 0000000..504138a
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/emailsender_test.py
@@ -0,0 +1,104 @@
+import mock
+
+class EmailSenderTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+
+    def set_comment_test(self):
+        import log_picker.sending.emailsender as email_s
+        
+        COMMENT = "test comment"
+        
+        obj = email_s.EmailSender("", "", "", "")
+        obj.set_comment(COMMENT)
+        
+        self.assertEqual(COMMENT, obj.comment)
+    
+    def sendfile_test(self):
+        import log_picker.sending.emailsender as email_s
+        
+        FILE = "/tmp/some_file"
+        MIMETYPE = "text/plain"
+        
+        email_s.smtplib = mock.Mock()
+        email_s.open = self.fs.open
+        self.fs.open(FILE, 'w').write('some file content\n')
+               
+        class Fake_MIMEMultipart(mock.Mock):
+            def __getitem__(self, key):
+                return self.__dict__[key]
+            
+            def __setitem__(self, key, value):
+                self.__dict__[key] = value
+        
+        email_s.email = mock.Mock()
+        email_s.email.mime.multipart.MIMEMultipart.return_value = \
+                                                            Fake_MIMEMultipart()
+               
+        obj = email_s.EmailSender("", "", "", "")
+        obj.sendfile(FILE, MIMETYPE)
+        
+        self.assertTrue(email_s.smtplib.SMTP().sendmail.called)
+        self.assertTrue(email_s.smtplib.SMTP().quit.called)
+        self.assertEqual(2,
+            len(email_s.email.mime.base.MIMEBase().set_payload.call_args_list))
+    
+    def sendfile_fail_1_test(self):
+        import log_picker.sending.emailsender as email_s
+        
+        FILE = "/tmp/some_file"
+        MIMETYPE = "text/plain"
+        
+        email_s.smtplib = mock.Mock()
+        import socket
+        email_s.smtplib.socket.gaierror = socket.gaierror
+        email_s.smtplib.SMTP.side_effect = email_s.smtplib.socket.gaierror()
+        email_s.open = self.fs.open
+        self.fs.open(FILE, 'w').write('some file content\n')
+               
+        class Fake_MIMEMultipart(mock.Mock):
+            def __getitem__(self, key):
+                return self.__dict__[key]
+            
+            def __setitem__(self, key, value):
+                self.__dict__[key] = value
+        
+        email_s.email = mock.Mock()
+        email_s.email.mime.multipart.MIMEMultipart.return_value = \
+                                                        Fake_MIMEMultipart()
+               
+        obj = email_s.EmailSender("", "", "", "")
+        self.assertRaises(email_s.SenderError, obj.sendfile, FILE, MIMETYPE)
+
+    def sendfile_fail_2_test(self):
+        import log_picker.sending.emailsender as email_s
+        
+        FILE = "/tmp/some_file"
+        MIMETYPE = "text/plain"
+        
+        email_s.smtplib = mock.Mock()
+        import smtplib
+        email_s.smtplib.SMTPRecipientsRefused = smtplib.SMTPRecipientsRefused
+        email_s.smtplib.SMTP().sendmail.side_effect = \
+                                            smtplib.SMTPRecipientsRefused("")
+        email_s.open = self.fs.open
+        self.fs.open(FILE, 'w').write('some file content\n')
+               
+        class Fake_MIMEMultipart(mock.Mock):
+            def __getitem__(self, key):
+                return self.__dict__[key]
+            
+            def __setitem__(self, key, value):
+                self.__dict__[key] = value
+        
+        email_s.email = mock.Mock()
+        email_s.email.mime.multipart.MIMEMultipart.return_value = \
+                                                        Fake_MIMEMultipart()
+               
+        obj = email_s.EmailSender("", "", "", "")
+        self.assertRaises(email_s.SenderError, obj.sendfile, FILE, MIMETYPE)
+    
diff --git a/old_tests/logpicker_test/sending_test/ftpsender_test.py b/old_tests/logpicker_test/sending_test/ftpsender_test.py
new file mode 100644
index 0000000..0bbc1e4
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/ftpsender_test.py
@@ -0,0 +1,156 @@
+import mock
+
+class FtpSenderTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def set_host_1_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        HOST = "foobar"
+        
+        obj = ftp_s.FtpSender()
+        obj.set_host(HOST)
+        
+        self.assertEqual("ftp://%s" % HOST, obj.host)
+    
+    def set_host_2_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        HOST = "ftp://foobar"
+        
+        obj = ftp_s.FtpSender()
+        obj.set_host(HOST)
+        
+        self.assertEqual(HOST, obj.host)
+    
+    def set_login_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        LOGIN = "spiderman"
+        PASSWORD = "jarfly"
+        
+        obj = ftp_s.FtpSender()
+        obj.set_login(LOGIN, PASSWORD)
+        
+        self.assertEqual(LOGIN, obj.username)
+        self.assertEqual(PASSWORD, obj.password)
+
+    def sendfile_1_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        ftp_s.open = self.fs.open
+        ftp_s.ftplib = mock.Mock()
+        ftp_s.os = mock.Mock()
+        ftp_s.os.path.basename = lambda x: x
+        ftp_s.file = lambda x: x
+        
+        HOST = "localhost"
+        FILE = "/tmp/somefile"
+        MIMETYPE = "application/x-bzip2"
+        
+        self.fs.open(FILE, 'w').write("some content")
+        
+        obj = ftp_s.FtpSender()
+        obj.set_host(HOST)
+        obj.sendfile(FILE, MIMETYPE)
+        
+        method_calls = ftp_s.ftplib.FTP().method_calls
+        method_names = [x[0] for x in ftp_s.ftplib.FTP().method_calls] 
+        
+        # Check calls order
+        self.assertEqual(method_names, 
+                ['connect', 'login', 'cwd', 'set_pasv', 'storbinary', 'quit'])
+        
+        # Check arguments
+        PARAMS = 1
+        
+        CONNECT = 0
+        LOGIN = 1
+        CWD = 2
+        SET_PASV = 3
+        STORBINARY = 4
+        QUIT = 5
+        
+        self.assertEqual(method_calls[CONNECT][PARAMS], (HOST, 21))
+        self.assertEqual(method_calls[LOGIN][PARAMS], ())
+        self.assertEqual(method_calls[CWD][PARAMS], ('',))
+        self.assertEqual(method_calls[SET_PASV][PARAMS], (True,))
+        self.assertEqual(method_calls[STORBINARY][PARAMS], 
+                                                    ('STOR %s' % FILE, FILE))
+                                                            
+    def sendfile_2_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        ftp_s.open = self.fs.open
+        ftp_s.ftplib = mock.Mock()
+        ftp_s.os = mock.Mock()
+        ftp_s.os.path.basename = lambda x: x
+        ftp_s.file = lambda x: x
+        
+        PORT = "55"
+        HOST = "localhost"
+        ADDRESS = "%s:%s" % (HOST, PORT)
+        USERNAME = "foo"
+        PASSWORD = "bar"
+        FILE = "/tmp/somefile"
+        MIMETYPE = "application/x-bzip2"
+        
+        self.fs.open(FILE, 'w').write("some content")
+        
+        obj = ftp_s.FtpSender()
+        obj.set_host(ADDRESS)
+        obj.set_login(USERNAME, PASSWORD)
+        obj.sendfile(FILE, MIMETYPE)
+        
+        method_calls = ftp_s.ftplib.FTP().method_calls
+        method_names = [x[0] for x in ftp_s.ftplib.FTP().method_calls] 
+        
+        # Check calls order
+        self.assertEqual(method_names, 
+                ['connect', 'login', 'cwd', 'set_pasv', 'storbinary', 'quit'])
+        
+        # Check arguments
+        PARAMS = 1
+        
+        CONNECT = 0
+        LOGIN = 1
+        CWD = 2
+        SET_PASV = 3
+        STORBINARY = 4
+        QUIT = 5
+        
+        self.assertEqual(method_calls[CONNECT][PARAMS], (HOST, PORT))
+        self.assertEqual(method_calls[LOGIN][PARAMS], (USERNAME, PASSWORD))
+        self.assertEqual(method_calls[CWD][PARAMS], ('',))
+        self.assertEqual(method_calls[SET_PASV][PARAMS], (True,))
+        self.assertEqual(method_calls[STORBINARY][PARAMS], 
+                                                    ('STOR %s' % FILE, FILE))
+    
+    def sendfile_fail_test(self):
+        import log_picker.sending.ftpsender as ftp_s
+        
+        ftp_s.open = self.fs.open
+        ftp_s.ftplib = mock.Mock()
+        ftp_s.os = mock.Mock()
+        ftp_s.file = mock.Mock()
+        import ftplib
+        ftp_s.ftplib = mock.Mock()
+        ftp_s.ftplib.all_errors = ftplib.all_errors
+        ftp_s.ftplib.FTP().storbinary.side_effect = ftplib.error_temp("some")
+        
+        HOST = "localhost"
+        FILE = "/tmp/somefile"
+        MIMETYPE = "application/x-bzip2"
+        
+        self.fs.open(FILE, 'w').write("some content")
+        
+        obj = ftp_s.FtpSender()
+        obj.set_host(HOST)
+        self.assertRaises(ftp_s.SenderError, obj.sendfile, FILE, MIMETYPE)
+        
+        
diff --git a/old_tests/logpicker_test/sending_test/localsender_test.py b/old_tests/logpicker_test/sending_test/localsender_test.py
new file mode 100644
index 0000000..cc9d888
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/localsender_test.py
@@ -0,0 +1,46 @@
+import os
+import shutil
+import mock
+
+class ScpSenderTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def set_path_test(self):
+        import log_picker.sending.localsender as local_s
+        
+        PATH = "/tmp/somewhere"
+        
+        obj = local_s.LocalSender()
+        obj.set_path(PATH)
+        
+        self.assertEqual(PATH, obj.path)
+    
+    def sendfile(self):
+        import log_picker.sending.localsender as local_s
+        
+        PATH = "/tmp/a_logfile_xa54hfd4j/"
+        FILE = "testfile"
+        
+        if os.path.exists(PATH):
+            if os.path.isdir(PATH):
+                shutil.rmtree(PATH)
+            else:
+                self.assertTrue(False, "Cannot create test directory: %s" % PATH)
+        
+        os.mkdir(PATH)
+        
+        obj = local_s.LocalSender()
+        obj.set_path(PATH)
+        obj.sendfile(FILE, "")
+        
+        files = len(os.listdir(PATH))
+        
+        shutil.rmtree(PATH)
+        
+        self.assertTrue(files)
+
diff --git a/old_tests/logpicker_test/sending_test/scpsender_test.py b/old_tests/logpicker_test/sending_test/scpsender_test.py
new file mode 100644
index 0000000..41c3ace
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/scpsender_test.py
@@ -0,0 +1,106 @@
+import mock
+
+class ScpSenderTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def set_host_1_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        HOST = "localhost"
+        
+        obj = scp_s.ScpSender()
+        obj.set_host(HOST)
+        
+        self.assertEqual(HOST, obj.host)
+    
+    def set_host_2_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        HOST = "localhost"
+        PORT = 12345
+        ADDRESS = "%s:%s" % (HOST, PORT)
+        
+        obj = scp_s.ScpSender()
+        obj.set_host(ADDRESS)
+        
+        self.assertEqual(HOST, obj.host)
+        self.assertEqual(PORT, obj.port)
+    
+    def set_host_3_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        HOST = "localhost"
+        PORT = "abc"
+        ADDRESS = "%s:%s" % (HOST, PORT)
+        
+        obj = scp_s.ScpSender()
+        obj.set_host(ADDRESS)
+        
+        self.assertEqual(HOST, obj.host)
+        self.assertEqual(None, obj.port)
+    
+    def set_login_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        USERNAME = "foo"
+        
+        obj = scp_s.ScpSender()
+        obj.set_login(USERNAME)
+        
+        self.assertEqual(USERNAME, obj.username)
+    
+    def set_path_1_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        PATH = "/tmp/something"
+        
+        obj = scp_s.ScpSender()
+        obj.set_path(PATH)
+        
+        self.assertEqual(PATH, obj.path)
+
+    def set_path_2_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        obj = scp_s.ScpSender()
+        obj.set_path(None)
+        
+        self.assertEqual(".", obj.path)
+    
+    def sendfile_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        FILE = "/tmp/file"
+        MIMETYPE = "text/plain"
+        USERNAME = "foo"
+        HOST = "localhost"
+        PATH = "/home/foo"
+        
+        scp_s.subprocess = mock.Mock()
+        scp_s.subprocess.Popen().returncode = False
+                
+        obj = scp_s.ScpSender()
+        obj.set_host(HOST)
+        obj.set_login(USERNAME)
+        obj.set_path(PATH)
+        obj.sendfile(FILE, MIMETYPE)
+        
+        TARGET = "%s@%s:%s" % (USERNAME, HOST, PATH)
+        self.assertTrue(TARGET in scp_s.subprocess.Popen.call_args[0][0])
+    
+    def sendfile_fail_1_test(self):
+        import log_picker.sending.scpsender as scp_s
+        
+        FILE = "/tmp/file"
+        MIMETYPE = "text/plain"
+        
+        scp_s.subprocess = mock.Mock()
+        
+        obj = scp_s.ScpSender()
+        self.assertRaises(scp_s.SenderError, obj.sendfile, FILE, MIMETYPE)
+
diff --git a/old_tests/logpicker_test/sending_test/senderbaseclass_test.py b/old_tests/logpicker_test/sending_test/senderbaseclass_test.py
new file mode 100644
index 0000000..8540ee5
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/senderbaseclass_test.py
@@ -0,0 +1,56 @@
+import mock
+
+class SenderBaseClassTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules([])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def get_description_1_test(self):
+        import log_picker.sending.senderbaseclass as senderbaseclass
+        
+        HOSTNAME = "tiger"
+        DATE = "2010-10-10"
+        
+        senderbaseclass.gethostname = mock.Mock(return_value = HOSTNAME)
+        
+        senderbaseclass.datetime = mock.Mock()
+        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
+        
+        obj = senderbaseclass.SenderBaseClass()
+        ret = obj._get_description()
+        self.assertEqual(ret, "%s (%s) %s" % ("", HOSTNAME, DATE))
+    
+    def get_description_2_test(self):
+        import log_picker.sending.senderbaseclass as senderbaseclass
+        
+        PREFIX = "description"
+        HOSTNAME = "lion"
+        DATE = "2011-11-11"
+        
+        senderbaseclass.gethostname = mock.Mock(return_value = HOSTNAME)
+        
+        senderbaseclass.datetime = mock.Mock()
+        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
+        
+        obj = senderbaseclass.SenderBaseClass()
+        ret = obj._get_description(PREFIX)
+        self.assertEqual(ret, "%s (%s) %s" % (PREFIX, HOSTNAME, DATE))
+
+    def get_description_3_test(self):
+        import log_picker.sending.senderbaseclass as senderbaseclass
+        
+        PREFIX = "description"
+        DATE = "2012-12-12"
+        
+        senderbaseclass.gethostname = mock.Mock(side_effect=Exception)
+        
+        senderbaseclass.datetime = mock.Mock()
+        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
+        
+        obj = senderbaseclass.SenderBaseClass()
+        ret = obj._get_description(PREFIX)
+        self.assertEqual(ret, "%s (%s) %s" % (PREFIX, "", DATE))
+
diff --git a/old_tests/logpicker_test/sending_test/stratasender_test.py b/old_tests/logpicker_test/sending_test/stratasender_test.py
new file mode 100644
index 0000000..fcb94b7
--- /dev/null
+++ b/old_tests/logpicker_test/sending_test/stratasender_test.py
@@ -0,0 +1,95 @@
+import mock
+
+class StrataSenderTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(['report.plugins.strata'])
+        self.fs = mock.DiskIO()
+    
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def set_login_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        LOGIN = "foo"
+        PASSWORD = "bar"
+        
+        obj = stratasender.StrataSender()
+        obj.set_login(LOGIN, PASSWORD)
+        
+        self.assertEqual(LOGIN, obj.username)
+        self.assertEqual(PASSWORD, obj.password)
+    
+    def set_case_number_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        CASE_NUM = "123"
+        
+        obj = stratasender.StrataSender()
+        obj.set_case_number(CASE_NUM)
+        self.assertEqual(CASE_NUM, obj.case_number)
+    
+    def sendfile_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        FILE = "/tmp/somefile"
+        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        <response><title>File Attachment Succeeded</title><body>.</body></response>'''
+        
+        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
+        
+        obj = stratasender.StrataSender()
+        obj.sendfile(FILE, "")
+        
+        self.assertTrue(stratasender.send_report_to_existing_case.called)
+    
+    def sendfile_raise_1_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        FILE = "/tmp/somefile"
+        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        <response><title>File Attachment Failed</title><body>401 Unauthorized
+        This request requires authentication....</body></response>'''
+        
+        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
+        
+        obj = stratasender.StrataSender()
+        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
+    
+    def sendfile_raise_2_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        FILE = "/tmp/somefile"
+        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        <response><title>File Attachment Failed</title><body>Error : CASE_NOT_FOUND
+        Message: Case 99999999 does not exist</body></response>'''
+        
+        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
+        
+        obj = stratasender.StrataSender()
+        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
+
+    def sendfile_raise_3_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        FILE = "/tmp/somefile"
+        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        <response><title>File Attachment Failed</title><body>Error : Your
+        computer is under attack of alien intruders (from Mars).</body></response>'''
+        
+        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
+        
+        obj = stratasender.StrataSender()
+        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
+
+    def sendfile_raise_4_test(self):
+        import log_picker.sending.stratasender as stratasender
+        
+        FILE = "/tmp/somefile"
+        RESPONSE = '''This is not XML valid response => something is wrong.'''
+        
+        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
+        
+        obj = stratasender.StrataSender()
+        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
+
diff --git a/old_tests/mock/Makefile.am b/old_tests/mock/Makefile.am
new file mode 100644
index 0000000..87ebd00
--- /dev/null
+++ b/old_tests/mock/Makefile.am
@@ -0,0 +1,21 @@
+# tests/Makefile.am for anaconda
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: David Cantrell <dcantrell at redhat.com>
+
+EXTRA_DIST = *.py
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/old_tests/mock/__init__.py b/old_tests/mock/__init__.py
new file mode 100644
index 0000000..3fd749a
--- /dev/null
+++ b/old_tests/mock/__init__.py
@@ -0,0 +1,94 @@
+# Mocking library for module and code injection, replay tests and other
+# unit testing purposes
+#
+# Copyright (C) 2010
+# Red Hat, Inc.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author(s): Martin Sivak <msivak at redhat.com>
+
+
+from disk import *
+from mock import *
+import unittest
+
+def slow(f):
+    """Decorates a test method as being slow, usefull for python-nose filtering"""
+    f.slow = True
+    return f
+
+def acceptance(f):
+    """Decorates test as belonging to acceptance testing and not useable in common devellopment unit testing. To be used with python-nose filtering."""
+    f.acceptance = True
+    return f
+
+class TestCase(unittest.TestCase):
+    def __init__(self, *args, **kwargs):
+        unittest.TestCase.__init__(self, *args, **kwargs)
+        self.injectedModules = {}
+
+    def setupModules(self, a):
+        """Mock specified list of modules and store the list so it can be
+           properly unloaded during tearDown"""
+
+        import sys
+        self.preexistingModules = set(sys.modules.keys())
+
+        for m in a:
+            sys.modules[m] = Mock()
+            self.injectedModules[m] = sys.modules[m]
+
+    def modifiedModule(self, mname, mod = None):
+        """Mark module (and all it's parents) as tainted"""
+
+        oldname=""
+        for m in mname.split("."):
+            self.injectedModules[oldname+m] = mod
+            oldname += m + "."
+        self.injectedModules[mname] = mod
+
+    def tearDownModules(self):
+        """Unload previously Mocked modules"""
+
+        import sys
+
+        for m in sys.modules.keys():
+            if m in self.preexistingModules and not m in self.injectedModules:
+                continue
+
+            del sys.modules[m]
+
+    def take_over_io(self, disk, target_module):
+        """ Trick target_module into using disk object as the filesystem.
+
+            This is achieved by overriding the module's 'open' binding as well
+            as many global bindings in os.path.
+        """
+        target_module.open = disk.open
+        self.modifiedModule(target_module.__name__)
+
+        import glob
+        self.modifiedModule("glob")
+        glob.glob = disk.glob_glob
+
+        import os
+        self.modifiedModule("os.path")
+        # this is what os.path implementaion points at, reimport:
+        import posixpath
+        self.modifiedModule("posixpath")
+        os.listdir = disk.os_listdir
+        os.path.exists = disk.os_path_exists
+        os.path.isdir = disk.os_path_isdir
+        os.access = disk.os_access
\ No newline at end of file
diff --git a/old_tests/mock/disk.py b/old_tests/mock/disk.py
new file mode 100644
index 0000000..926fe8f
--- /dev/null
+++ b/old_tests/mock/disk.py
@@ -0,0 +1,128 @@
+# Copyright (C) 2010
+# Red Hat, Inc.  All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author(s): Martin Sivak <msivak at redhat.com>
+
+from StringIO import StringIO
+import fnmatch
+import os
+
+class DiskIO(object):
+    """Simple object to simplify mocking of file operations in Mock
+       based testing"""
+
+    class TestFile(StringIO):
+        def __init__(self, store, path, content = ""):
+            StringIO.__init__(self, content)
+            self._store = store
+            self._path = path
+            self._ro = False
+
+        def flush(self):
+            self._store[self._path] = self.getvalue()
+
+        def close(self):
+            self.flush()
+            return StringIO.close(self)
+
+        def __del__(self):
+            try:
+                self.close()
+            except (AttributeError, ValueError):
+                pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *_):
+            self.close()
+
+    class Dir(object):
+        pass
+
+    class Link(object):
+        pass
+
+    def __init__(self):
+        self.reset()
+
+    def __getitem__(self, key):
+        return self.fs[key]
+
+    def __setitem__(self, key, value):
+        self.fs[key] = value
+
+    def reset(self):
+        self.fs = {
+            "/proc": self.Dir,
+            "/proc/cmdline": "linux",
+        }
+        self._pwd = "/"
+
+    #Emulate file objects
+    def open(self, filename, mode = "r"):
+        path = os.path.join(self._pwd, filename)
+        content = self.fs.get(path, None)
+        if content == self.Dir:
+            raise IOError("[Errno 21] Is a directory: '%s'" % (path))
+        elif mode.startswith("w"):
+            self.fs[path] = ""
+            f = self.TestFile(self.fs, path, self.fs[path])
+        elif mode.endswith("a"):
+            if not path in self.fs:
+                self.fs[path] = ""
+            f = self.TestFile(self.fs, path, self.fs[path])
+            f.seek(0, os.SEEK_END)
+        elif content == None:
+            raise IOError("[Errno 2] No such file or directory: '%s'" % (path,))
+        elif mode.endswith("+"):
+            f = self.TestFile(self.fs, path, content)
+            if mode.startswith('r'):
+                f.seek(0, os.SEEK_SET)
+            else:
+                f.seek(0, os.SEEK_END)
+        else:
+            f = self.TestFile(self.fs, path, content)
+
+        return f
+
+    #Emulate os calls
+    def glob_glob(self, pattern):
+        return fnmatch.filter(self.fs.keys(), pattern)
+
+    def os_listdir(self, path):
+        return [entry[len(path):].lstrip('/') for entry in self.fs.keys()\
+                    if entry.startswith(path) and entry != path]
+
+    def os_path_exists(self, path):
+        path = os.path.join(self._pwd, path)
+        return self.fs.has_key(path)
+
+    def os_path_isdir(self, path):
+        if not path.endswith("/"):
+            path += "/"
+        path += "*"
+        return len(fnmatch.filter(self.fs.keys(), path)) > 0
+
+    def os_remove(self, path):
+        path = os.path.join(self._pwd, path)
+        try:
+            del self.fs[path]
+        except KeyError:
+            raise OSError("[Errno 2] No such file or directory: '%s'" % (path,))
+
+    def os_access(self, path, mode):
+        return self.os_path_exists(path)
diff --git a/old_tests/mock/mock.py b/old_tests/mock/mock.py
new file mode 100644
index 0000000..9053e81
--- /dev/null
+++ b/old_tests/mock/mock.py
@@ -0,0 +1,271 @@
+# mock.py
+# Test tools for mocking and patching.
+# Copyright (C) 2007-2009 Michael Foord
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+
+# mock 0.6.0
+# http://www.voidspace.org.uk/python/mock/
+
+# Released subject to the BSD License
+# Please see http://www.voidspace.org.uk/python/license.shtml
+
+# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
+# Comments, suggestions and bug reports welcome.
+
+
+__all__ = (
+    'Mock',
+    'patch',
+    'patch_object',
+    'sentinel',
+    'DEFAULT'
+)
+
+__version__ = '0.6.0'
+
+class SentinelObject(object):
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return '<SentinelObject "%s">' % self.name
+
+
+class Sentinel(object):
+    def __init__(self):
+        self._sentinels = {}
+
+    def __getattr__(self, name):
+        return self._sentinels.setdefault(name, SentinelObject(name))
+
+
+sentinel = Sentinel()
+
+DEFAULT = sentinel.DEFAULT
+
+class OldStyleClass:
+    pass
+ClassType = type(OldStyleClass)
+
+def _is_magic(name):
+    return '__%s__' % name[2:-2] == name
+
+def _copy(value):
+    if type(value) in (dict, list, tuple, set):
+        return type(value)(value)
+    return value
+
+
+class Mock(object):
+
+    def __init__(self, spec=None, side_effect=None, return_value=DEFAULT,
+                 name=None, parent=None, wraps=None):
+        self._parent = parent
+        self._name = name
+        if spec is not None and not isinstance(spec, list):
+            spec = [member for member in dir(spec) if not _is_magic(member)]
+
+        self._methods = spec
+        self._children = {}
+        self._return_value = return_value
+        self.side_effect = side_effect
+        self._wraps = wraps
+
+        self.reset_mock()
+
+
+    def reset_mock(self):
+        self.called = False
+        self.call_args = None
+        self.call_count = 0
+        self.call_args_list = []
+        self.method_calls = []
+        for child in self._children.itervalues():
+            child.reset_mock()
+        if isinstance(self._return_value, Mock):
+            self._return_value.reset_mock()
+
+
+    def __get_return_value(self):
+        if self._return_value is DEFAULT:
+            self._return_value = Mock()
+        return self._return_value
+
+    def __set_return_value(self, value):
+        self._return_value = value
+
+    return_value = property(__get_return_value, __set_return_value)
+
+
+    def __call__(self, *args, **kwargs):
+        self.called = True
+        self.call_count += 1
+        self.call_args = (args, kwargs)
+        self.call_args_list.append((args, kwargs))
+
+        parent = self._parent
+        name = self._name
+        while parent is not None:
+            parent.method_calls.append((name, args, kwargs))
+            if parent._parent is None:
+                break
+            name = parent._name + '.' + name
+            parent = parent._parent
+
+        ret_val = DEFAULT
+        if self.side_effect is not None:
+            if (isinstance(self.side_effect, Exception) or
+                isinstance(self.side_effect, (type, ClassType)) and
+                issubclass(self.side_effect, Exception)):
+                raise self.side_effect
+
+            ret_val = self.side_effect(*args, **kwargs)
+            if ret_val is DEFAULT:
+                ret_val = self.return_value
+
+        if self._wraps is not None and self._return_value is DEFAULT:
+            return self._wraps(*args, **kwargs)
+        if ret_val is DEFAULT:
+            ret_val = self.return_value
+        return ret_val
+
+
+    def __getattr__(self, name):
+        if self._methods is not None:
+            if name not in self._methods:
+                raise AttributeError("Mock object has no attribute '%s'" % name)
+        elif _is_magic(name):
+            raise AttributeError(name)
+
+        if name not in self._children:
+            wraps = None
+            if self._wraps is not None:
+                wraps = getattr(self._wraps, name)
+            self._children[name] = Mock(parent=self, name=name, wraps=wraps)
+
+        return self._children[name]
+
+
+    def assert_called_with(self, *args, **kwargs):
+        assert self.call_args == (args, kwargs), 'Expected: %s\nCalled with: %s' % ((args, kwargs), self.call_args)
+
+
+def _dot_lookup(thing, comp, import_path):
+    try:
+        return getattr(thing, comp)
+    except AttributeError:
+        __import__(import_path)
+        return getattr(thing, comp)
+
+
+def _importer(target):
+    components = target.split('.')
+    import_path = components.pop(0)
+    thing = __import__(import_path)
+
+    for comp in components:
+        import_path += ".%s" % comp
+        thing = _dot_lookup(thing, comp, import_path)
+    return thing
+
+
+class _patch(object):
+    def __init__(self, target, attribute, new, spec, create):
+        self.target = target
+        self.attribute = attribute
+        self.new = new
+        self.spec = spec
+        self.create = create
+        self.has_local = False
+
+
+    def __call__(self, func):
+        if hasattr(func, 'patchings'):
+            func.patchings.append(self)
+            return func
+
+        def patched(*args, **keywargs):
+            # don't use a with here (backwards compatability with 2.5)
+            extra_args = []
+            for patching in patched.patchings:
+                arg = patching.__enter__()
+                if patching.new is DEFAULT:
+                    extra_args.append(arg)
+            args += tuple(extra_args)
+            try:
+                return func(*args, **keywargs)
+            finally:
+                for patching in getattr(patched, 'patchings', []):
+                    patching.__exit__()
+
+        patched.patchings = [self]
+        patched.__name__ = func.__name__
+        patched.compat_co_firstlineno = getattr(func, "compat_co_firstlineno",
+                                                func.func_code.co_firstlineno)
+        return patched
+
+
+    def get_original(self):
+        target = self.target
+        name = self.attribute
+        create = self.create
+
+        original = DEFAULT
+        if _has_local_attr(target, name):
+            try:
+                original = target.__dict__[name]
+            except AttributeError:
+                # for instances of classes with slots, they have no __dict__
+                original = getattr(target, name)
+        elif not create and not hasattr(target, name):
+            raise AttributeError("%s does not have the attribute %r" % (target, name))
+        return original
+
+
+    def __enter__(self):
+        new, spec, = self.new, self.spec
+        original = self.get_original()
+        if new is DEFAULT:
+            # XXXX what if original is DEFAULT - shouldn't use it as a spec
+            inherit = False
+            if spec == True:
+                # set spec to the object we are replacing
+                spec = original
+                if isinstance(spec, (type, ClassType)):
+                    inherit = True
+            new = Mock(spec=spec)
+            if inherit:
+                new.return_value = Mock(spec=spec)
+        self.temp_original = original
+        setattr(self.target, self.attribute, new)
+        return new
+
+
+    def __exit__(self, *_):
+        if self.temp_original is not DEFAULT:
+            setattr(self.target, self.attribute, self.temp_original)
+        else:
+            delattr(self.target, self.attribute)
+        del self.temp_original
+
+
+def patch_object(target, attribute, new=DEFAULT, spec=None, create=False):
+    return _patch(target, attribute, new, spec, create)
+
+
+def patch(target, new=DEFAULT, spec=None, create=False):
+    try:
+        target, attribute = target.rsplit('.', 1)
+    except (TypeError, ValueError):
+        raise TypeError("Need a valid target to patch. You supplied: %r" % (target,))
+    target = _importer(target)
+    return _patch(target, attribute, new, spec, create)
+
+
+
+def _has_local_attr(obj, name):
+    try:
+        return name in vars(obj)
+    except TypeError:
+        # objects without a __dict__
+        return hasattr(obj, name)
diff --git a/old_tests/pyanaconda_test/Makefile.am b/old_tests/pyanaconda_test/Makefile.am
new file mode 100644
index 0000000..889d867
--- /dev/null
+++ b/old_tests/pyanaconda_test/Makefile.am
@@ -0,0 +1,45 @@
+# tests/pyanaconda_test/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Tomas Mlcoch <tmlcoch at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
+
+ANACDIR = $(top_builddir)/pyanaconda
+TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir)
+
+TESTS = backend_test.py \
+    bootloader_test.py \
+    cmdline_test.py \
+    desktop_test.py \
+    flags_test.py \
+    image_test.py \
+    language_test.py \
+    network_test.py \
+    packages_test.py \
+    packaging_test.py \
+    partintfhelpers_test.py \
+    product_test.py \
+    rescue_test.py \
+    security_test.py \
+    simpleconfig_test.py \
+    timezone_test.py \
+    upgrade_test.py \
+    users_test.py \
+    vnc_test.py
diff --git a/old_tests/pyanaconda_test/backend_test.py b/old_tests/pyanaconda_test/backend_test.py
new file mode 100644
index 0000000..b09ee69
--- /dev/null
+++ b/old_tests/pyanaconda_test/backend_test.py
@@ -0,0 +1,227 @@
+#!/usr/bin/python
+
+import mock
+
+class BackendTest(mock.TestCase):
+
+    def setUp(self):
+        import pykickstart.commands
+
+        self.setupModules(["_isys", "block", 'parted', 'storage',
+                    'pyanaconda.storage.formats', 'logging',
+                    'logging.config',
+                    'ConfigParser', 'pyanaconda.anaconda_log',
+                    'pyanaconda.storage.storage_log',
+                    'pyanaconda.yuminstall'])
+
+        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()
+        ab = pyanaconda.backend.AnacondaBackend(anaconda)
+        ab.copyFirmware()
+        self.assertEqual(pyanaconda.backend.shutil.copyfile.call_args[0][0], FILE)
+
+    def anaconda_backend_do_post_install_test(self):
+        import pyanaconda.backend
+        from pyanaconda.constants import ROOT_PATH
+        FILE = 'foo'
+        A = 'a'
+        B = 'b'
+        C = 'c'
+        pyanaconda.backend.AnacondaBackend.copyFirmware = mock.Mock()
+        pyanaconda.backend.AnacondaBackend.kernelVersionList = mock.Mock(
+            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.extraModules = True
+
+        ab = pyanaconda.backend.AnacondaBackend(anaconda)
+        ab.doPostInstall(anaconda)
+
+        self.assertEqual(pyanaconda.backend.packages.method_calls[0],
+            ('recreateInitrd', (A, ROOT_PATH), {}))
+        self.assertEqual(pyanaconda.backend.shutil.method_calls[0],
+            ('copytree', (FILE, ROOT_PATH + '/root/'), {}))
+        self.assertEqual(pyanaconda.backend.shutil.method_calls[1],
+            ('copytree', (self.DD_EXTRACTED, ROOT_PATH + '/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()
+        anaconda = mock.Mock()
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        ab.getDefaultGroups(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)
+        ab.writeConfiguration()
+        self.assertTrue(self.logger.warning.called)
+
+    def do_backend_setup_1_test(self):
+        import pyanaconda.backend
+        RET = -1
+        pyanaconda.backend.DISPATCH_BACK = RET
+        anaconda = mock.Mock()
+        anaconda.backend.doBackendSetup.return_value = RET
+        ret = pyanaconda.backend.doBackendSetup(anaconda)
+        self.assertEqual(RET, ret)
+
+    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)
+
+    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/old_tests/pyanaconda_test/bootloader_test.py b/old_tests/pyanaconda_test/bootloader_test.py
new file mode 100644
index 0000000..6aa93bb
--- /dev/null
+++ b/old_tests/pyanaconda_test/bootloader_test.py
@@ -0,0 +1,59 @@
+import mock
+
+class ArgumentsTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(
+            ['_isys', 'logging', 'pyanaconda.anaconda_log', 'block',
+             'pyanaconda.storage',
+             'pyanaconda.storage.devicelibs',
+             'pyanaconda.storage.errors'])
+
+        import pyanaconda
+        pyanaconda.anaconda_log = mock.Mock()
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def test_basic(self):
+        from pyanaconda.bootloader import Arguments
+        a = Arguments()
+        a.update(set(["a", "b", "c"]))
+        b = Arguments()
+        b.add("b")
+        diff = a - b
+        self.assertEqual(diff, set(["a", "c"]))
+        self.assertIsInstance(diff, Arguments)
+        assert(str(diff) in ["a c", "c a"])
+
+    def test_merge_ip(self):
+        from pyanaconda.bootloader import Arguments
+        # test that _merge_ip() doesnt break the simple case:
+        a = Arguments(["one", "two", "ip=eth0:dhcp"])
+        a._merge_ip()
+        self.assertEqual(a, Arguments(["one", "two", "ip=eth0:dhcp"]))
+
+        # test that it does what it's supposed to:
+        a = Arguments(["one", "two", "ip=eth0:dhcp", "ip=eth0:auto6",
+                       "ip=wlan0:dhcp",
+                       "ip=10.34.102.102::10.34.39.255:24:aklab:eth2:none"])
+        a._merge_ip()
+        self.assertEqual(a, set([
+                    "one", "two",
+                    "ip=wlan0:dhcp",
+                    "ip=10.34.102.102::10.34.39.255:24:aklab:eth2:none",
+                    "ip=eth0:auto6,dhcp"]))
+
+    def test_output_with_merge(self):
+        from pyanaconda.bootloader import Arguments
+        a = Arguments(["ip=eth0:dhcp"])
+        self.assertEqual(str(a), "ip=eth0:dhcp")
+        a = Arguments(["ip=eth0:dhcp", "ip=eth0:auto6"])
+        assert(str(a) in ["ip=eth0:auto6,dhcp", "ip=eth0:dhcp,auto6"])
+
+    def test_sorting(self):
+        from pyanaconda.bootloader import Arguments
+        a = Arguments(["ip=eth0:dhcp", "rhgb", "quiet",
+                       "root=/dev/mapper/destroyers-rubies", "rd.md=0",
+                       "rd.luks=0"])
+        # 'rhgb quiet' should be the final entries:
+        assert(str(a).endswith("rhgb quiet"))
diff --git a/old_tests/pyanaconda_test/desktop_test.py b/old_tests/pyanaconda_test/desktop_test.py
new file mode 100644
index 0000000..2078c9a
--- /dev/null
+++ b/old_tests/pyanaconda_test/desktop_test.py
@@ -0,0 +1,100 @@
+#!/usr/bin/python
+
+import mock
+import sys
+
+class DesktopTest(mock.TestCase):
+
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])
+        self.fs = mock.DiskIO()
+
+        self.fs.open('/mnt/sysimage/etc/inittab', 'w').write('id:5:initdefault:')
+        self.fs.open('/mnt/sysimage/etc/sysconfig/desktop', 'w').write('')
+
+        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()
+        dskt.setDefaultRunLevel(3)
+        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')
+
+    def write_1_test(self):
+        import pyanaconda.desktop
+        dskt = pyanaconda.desktop.Desktop()
+        dskt.write()
+        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
+                         'id:3:initdefault:')
+
+    def write_2_test(self):
+        import pyanaconda.desktop
+        dskt = pyanaconda.desktop.Desktop()
+        dskt.setDefaultRunLevel(5)
+        dskt.write()
+        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
+                         'id:5:initdefault:')
+
+    def write_3_test(self):
+        import pyanaconda.desktop
+        pyanaconda.desktop.os = mock.Mock()
+        pyanaconda.desktop.os.path.isdir.return_value = True
+        dskt = pyanaconda.desktop.Desktop()
+        dskt.setDefaultDesktop('foo')
+        dskt.write()
+        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
+                         'id:3:initdefault:')
+        self.assertEqual(self.fs['/mnt/sysimage/etc/sysconfig/desktop'],
+                         'DESKTOP="foo"\n')
+
diff --git a/old_tests/pyanaconda_test/flags_test.py b/old_tests/pyanaconda_test/flags_test.py
new file mode 100644
index 0000000..e4046d5
--- /dev/null
+++ b/old_tests/pyanaconda_test/flags_test.py
@@ -0,0 +1,132 @@
+#!/usr/bin/python
+
+# Test Bug 500198
+
+import mock
+import sys
+
+
+class FlagsTest(mock.TestCase):
+    """Simulate /proc/cmdline parameters parsing (#500198)"""
+
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])
+
+        self.fs = mock.DiskIO()
+
+        import pyanaconda.flags
+
+        self.mock2 = mock.Mock()
+        pyanaconda.flags.open = mock.Mock(return_value=self.mock2)
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def createcmdlinedict_1_test(self):
+        """/proc/cmdline without BOOT_IMAGE param"""
+        import pyanaconda.flags
+
+        self.cmd = 'vmlinuz initrd=initrd.img stage2=hd:LABEL="Fedora" xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        cmddict = pyanaconda.flags.flags.createCmdlineDict()
+
+        self.assertEqual(set(cmddict.keys()),
+            set(['vmlinuz', 'initrd', 'stage2', 'xdriver', 'nomodeset']))
+
+    def createcmdlinedict_2_test(self):
+        """/proc/cmdline param: quotes at end"""
+        import pyanaconda.flags
+
+        self.cmd = 'vmlinuz BOOT_IMAGE=/boot/img initrd=initrd.img stage2=hd:LABEL="Fedora"'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        try:
+            cmddict = pyanaconda.flags.flags.createCmdlineDict()
+        except (ValueError):
+            self.assertTrue(False, "ValueError exception was raised.")
+
+        self.assertEqual(set(cmddict.keys()),
+            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
+
+    def createcmdlinedict_3_test(self):
+        """/proc/cmdline param BOOT_IMAGE with quotes (no quotes at end)"""
+        import pyanaconda.flags
+
+        self.cmd = 'vmlinuz BOOT_IMAGE="img img" initrd=initrd.img'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        cmddict = pyanaconda.flags.flags.createCmdlineDict()
+
+        self.assertEqual(set(cmddict.keys()),
+            set(['vmlinuz', 'BOOT_IMAGE', 'initrd']))
+
+    def createcmdlinedict_4_test(self):
+        """/proc/cmdline param BOOT_IMAGE with quotes (no quotes at end) v2"""
+        import pyanaconda.flags
+
+        self.cmd = 'vmlinuz BOOT_IMAGE="/boot/img" stage2=hd:LABEL="Fedora" initrd=initrd.img'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        cmddict = pyanaconda.flags.flags.createCmdlineDict()
+
+        self.assertEqual(set(cmddict.keys()),
+            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
+
+    def createcmdlinedict_5_test(self):
+        """/proc/cmdline param: BOOT_IMAGE with quotes (+ quotes at end)"""
+        import pyanaconda.flags
+
+        self.cmd = 'vmlinuz BOOT_IMAGE="/boot/img img" initrd=initrd.img stage2=hd:LABEL="Fedora"'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        try:
+            cmddict = pyanaconda.flags.flags.createCmdlineDict()
+        except (ValueError):
+            self.assertTrue(False, "ValueError exception was raised.")
+
+        self.assertEqual(set(cmddict.keys()),
+            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
+
+    def setattr_getattr_1_test(self):
+        import pyanaconda.flags
+        RET = 1
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        pyanaconda.flags.flags.sshd = RET
+        self.assertEqual(RET, pyanaconda.flags.flags.sshd)
+
+    def setattr_getattr_2_test(self):
+        import pyanaconda.flags
+        RET = 0
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        pyanaconda.flags.flags.sshd = RET
+        self.assertEqual(RET, pyanaconda.flags.flags.sshd)
+
+    def setattr_getattr_3_test(self):
+        import pyanaconda.flags
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+
+        def f(): return pyanaconda.flags.flags.fooattr
+        self.assertRaises(AttributeError, f)
+
+    def setattr_getattr_4_test(self):
+        import pyanaconda.flags
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+
+        def f(): pyanaconda.flags.flags.fooattr = 1
+        self.assertRaises(AttributeError, f)
+
+    def get_1_test(self):
+        import pyanaconda.flags
+        RET = 'text'
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        ret = pyanaconda.flags.flags.get('foobar', RET)
+        self.assertEqual(RET, ret)
+
+    def get_2_test(self):
+        import pyanaconda.flags
+        RET = 'text'
+        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
+        self.mock2.read = mock.Mock(return_value=self.cmd)
+        ret = pyanaconda.flags.flags.get('sshd', RET)
+        self.assertNotEqual(RET, ret)
diff --git a/old_tests/pyanaconda_test/image_test.py b/old_tests/pyanaconda_test/image_test.py
new file mode 100644
index 0000000..f3faeac
--- /dev/null
+++ b/old_tests/pyanaconda_test/image_test.py
@@ -0,0 +1,147 @@
+#!/usr/bin/python
+
+import mock
+import sys
+
+IMAGENAME = 'Fedora-13-i386-DVD.iso'
+
+class ImageTest(mock.TestCase):
+    
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])            
+        self.fs = mock.DiskIO()
+        
+        DISCINFO = "1273712438.740122\n"
+        DISCINFO += "Fedora 13\n"
+        DISCINFO += "i386\n"
+        DISCINFO += "ALL\n"
+
+        DISCINFO2 = "1273712438.740122\n"
+        DISCINFO2 += "Fedora 13\n"
+        DISCINFO2 += "i386\n"
+        DISCINFO2 += "1,2\n"
+        
+        self.fs.open('/mnt/install/cdimage/.discinfo', 'w').write(DISCINFO)
+        self.fs.open('/tmp/.discinfo', 'w').write(DISCINFO2)
+        
+        import pyanaconda.image     
+        pyanaconda.image.gettext = mock.Mock()  
+        pyanaconda.image.log = mock.Mock()    
+        pyanaconda.image.open = self.fs.open
+        pyanaconda.image.isys = mock.Mock()
+        pyanaconda.image._arch = 'i386'
+        pyanaconda.image.stat = mock.Mock()
+        pyanaconda.image.stat.ST_SIZE = 0
+        
+        pyanaconda.image.os = mock.Mock()
+        pyanaconda.image.os.R_OK = 0
+        pyanaconda.image.os.stat.return_value = [2048]
+        pyanaconda.image.os.listdir.return_value=[IMAGENAME]
+    
+    def tearDown(self):
+        self.tearDownModules()
+        
+    def get_media_id_1_test(self):
+        import pyanaconda.image
+        ret = pyanaconda.image.getMediaId('/mnt/install/cdimage')
+        self.assertEqual(ret, '1273712438.740122') 
+        
+    def get_media_id_2_test(self):         
+        import pyanaconda.image
+        pyanaconda.image.os.access = mock.Mock(return_value=False)
+        ret = pyanaconda.image.getMediaId('/')
+        self.assertEqual(ret, None)      
+        
+    def mount_directory_1_test(self):   
+        import pyanaconda.image
+        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
+        pyanaconda.image.mountDirectory('hd:/dev/sda1:/', mock.Mock())
+        self.assertEqual(pyanaconda.image.isys.method_calls,
+            [('mount', ('/dev/sda1', '/mnt/install/isodir'), {'fstype': 'auto', 'options':''})])
+            
+    def mount_directory_2_test(self):   
+        import pyanaconda.image
+        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
+        pyanaconda.image.mountDirectory('hd:sda1:/', mock.Mock())
+        self.assertEqual(pyanaconda.image.isys.method_calls,
+            [('mount', ('/dev/sda1', '/mnt/install/isodir'), {'fstype': 'auto', 'options':''})])
+            
+    def mount_directory_3_test(self):   
+        import pyanaconda.image
+        pyanaconda.image.os.path.ismount = mock.Mock(return_value=True)
+        pyanaconda.image.mountDirectory('hd:sda1:/', mock.Mock())
+        self.assertEqual(pyanaconda.image.isys.method_calls, []) 
+        
+    def mount_image_1_test(self):
+        import pyanaconda.image
+        self.assertRaises(SystemError, pyanaconda.image.mountImage, '', '/mnt/install/cdimage', mock.Mock())
+     
+    def mount_image_2_test(self):
+        import pyanaconda.image
+        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
+        ret = pyanaconda.image.mountImage('', '/mnt/install/cdimage', mock.Mock())
+
+        self.assertEqual(pyanaconda.image.isys.method_calls,
+           [('isIsoImage', ('/Fedora-13-i386-DVD.iso',), {}),
+            ('mount', ('/Fedora-13-i386-DVD.iso', '/mnt/install/cdimage'),
+                                    {'readOnly': True, 'fstype': 'iso9660'}),
+            ('umount', ('/mnt/install/cdimage',), {'removeDir': False}),
+            ('mount', ('/Fedora-13-i386-DVD.iso', '/mnt/install/cdimage'),
+                                    {'readOnly': True, 'fstype': 'iso9660'}),
+           ])
+        
+    def scan_for_media_1_test(self):
+        import pyanaconda.image
+        storage = mock.Mock()
+        storage.devicetree.devices = []
+        ret = pyanaconda.image.scanForMedia(mock.Mock(), storage)
+        self.assertEqual(ret, None)
+        
+    def scan_for_media_2_test(self):
+        import pyanaconda.image
+        device = mock.Mock()
+        device.type = 'cdrom'
+        device.name = 'deviceName'
+        storage = mock.Mock()
+        storage.devicetree.devices = [device]
+        ret = pyanaconda.image.scanForMedia('/tmp', storage)
+        self.assertEqual(ret, 'deviceName')
+        self.assertEqual(device.method_calls, 
+            [('format.mount', (), {'mountpoint': '/tmp'})])
+            
+    def umount_image_1_test(self):
+        import pyanaconda.image
+        pyanaconda.image.umountImage('/tmp')
+        self.assertEqual(pyanaconda.image.isys.method_calls, 
+            [('umount', ('/tmp',), {'removeDir': False})])
+             
+    def unmount_cd_1_test(self):
+        import pyanaconda.image
+        window = mock.Mock()
+        pyanaconda.image.unmountCD(None, window)
+        self.assertEqual(window.method_calls, [])
+
+    def unmount_cd_2_test(self):
+        import pyanaconda.image
+        window = mock.Mock()
+        device = mock.Mock()
+        pyanaconda.image.unmountCD(device, window)
+        self.assertEqual(window.method_calls, [])
+        self.assertEqual(device.method_calls,
+            [('format.unmount', (), {})])
+        
+    def verify_media_1_test(self):
+        import pyanaconda.image
+        ret = pyanaconda.image.verifyMedia('/tmp')
+        self.assertTrue(ret)
+        
+    def verify_media_2_test(self):
+        import pyanaconda.image
+        ret = pyanaconda.image.verifyMedia('/tmp', timestamp=1337)
+        self.assertFalse(ret)
+        
+    def verify_media_3_test(self):
+        import pyanaconda.image
+        pyanaconda.image._arch = 'x86_64'
+        ret = pyanaconda.image.verifyMedia('/tmp', 1)
+        self.assertFalse(ret)
diff --git a/old_tests/pyanaconda_test/indexed_dict_test.py b/old_tests/pyanaconda_test/indexed_dict_test.py
new file mode 100644
index 0000000..14185b6
--- /dev/null
+++ b/old_tests/pyanaconda_test/indexed_dict_test.py
@@ -0,0 +1,49 @@
+import mock
+
+class IndexedDictTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(['_isys'])
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def instantiation_test(self):
+        from pyanaconda.indexed_dict import IndexedDict
+        d = IndexedDict()
+        self.assertIsInstance(d, IndexedDict)
+
+    def append_test(self):
+        from pyanaconda.indexed_dict import IndexedDict
+        d = IndexedDict()
+        stored_data = [1, 2, 3]
+        d["some_step"] = stored_data
+        self.assertIs(d["some_step"], stored_data)
+
+    def cant_append_test(self):
+        from pyanaconda.indexed_dict import IndexedDict
+        def assign_int(indexed_dict):
+            indexed_dict[3] = [1, 2, 3]
+        d = IndexedDict()
+        self.assertRaises(TypeError, d.__setitem__, 3, [1, 2, 3])
+
+    def referencing_test(self):
+        from pyanaconda.indexed_dict import IndexedDict
+        d = IndexedDict()
+        d["first"] = 10
+        d["second"] = 20
+        d["third"] = 30
+        self.assertEqual(d[0], 10)
+        self.assertEqual(d[1], 20)
+        self.assertEqual(d[2], 30)
+        self.assertRaises(IndexError, d.__getitem__, 3)
+
+    def index_test(self):
+        from pyanaconda.indexed_dict import IndexedDict
+        d = IndexedDict()
+        d["first"] = 10
+        d["second"] = 20
+        d["third"] = 30
+
+        self.assertEqual(d.index("first"), 0)
+        self.assertEqual(d.index("second"), 1)
+        self.assertEqual(d.index("third"), 2)
diff --git a/old_tests/pyanaconda_test/iutil_test.py b/old_tests/pyanaconda_test/iutil_test.py
new file mode 100644
index 0000000..2f143ec
--- /dev/null
+++ b/old_tests/pyanaconda_test/iutil_test.py
@@ -0,0 +1,37 @@
+import mock
+import sys
+
+class IutilTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(
+            ['_isys', 'logging', 'pyanaconda.anaconda_log', 'block'])
+
+        import pyanaconda
+        pyanaconda.anaconda_log = mock.Mock()
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def copy_to_sysimage_test(self):
+        from pyanaconda import iutil
+        fs = mock.DiskIO()
+        self.take_over_io(fs, iutil)
+        self.assertEqual(iutil.copy_to_sysimage("/etc/securetty"), False)
+
+        fs["/etc/securetty"] = "tty1"
+        iutil.os.makedirs = mock.Mock()
+        iutil.shutil.copy = mock.Mock()
+        self.assertEqual(iutil.copy_to_sysimage("/etc/securetty"), True)
+        iutil.os.makedirs.assert_called_with("/mnt/sysimage/etc")
+        iutil.shutil.copy.assert_called_with("/etc/securetty",
+                                             "/mnt/sysimage/etc/securetty")
+
+    def testExecCaptureNonZeroFatal (self):
+        import iutil
+        try:
+            argv = ["-c", "import sys; sys.exit(3);"]
+            iutil.execWithCapture(sys.executable, argv, root=None, fatal=True)
+        except RuntimeError, ex:
+            self.assertIn("return code: 3", str(ex))
+        else:
+            self.fail("RuntimeError not raised")
diff --git a/old_tests/pyanaconda_test/network_test.py b/old_tests/pyanaconda_test/network_test.py
new file mode 100644
index 0000000..756c11d
--- /dev/null
+++ b/old_tests/pyanaconda_test/network_test.py
@@ -0,0 +1,389 @@
+#!/usr/bin/python
+
+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
+        pyanaconda.network.open = self.fs.open
+        pyanaconda.simpleconfig.open = self.fs.open
+        pyanaconda.network.sysconfigDir = self.SYSCONFIGDIR
+        pyanaconda.network.netscriptsDir = self.NETSCRIPTSDIR
+        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.setNMControlledDevices_backup = pyanaconda.network.Network.setNMControlledDevices
+        pyanaconda.network.Network.setNMControlledDevices = mock.Mock()
+        pyanaconda.network.Network.netdevices = {}
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def sanity_check_hostname_1_test(self):
+        import pyanaconda.network
+        (valid, err) = pyanaconda.network.sanityCheckHostname('desktop')
+        self.assertTrue(valid)
+
+    def sanity_check_hostname_2_test(self):
+        import pyanaconda.network
+        (valid, err) = pyanaconda.network.sanityCheckHostname('')
+        self.assertFalse(valid)
+
+    def sanity_check_hostname_3_test(self):
+        import pyanaconda.network
+        (valid, err) = pyanaconda.network.sanityCheckHostname('c'*256)
+        self.assertFalse(valid)
+
+    def sanity_check_hostname_4_test(self):
+        import pyanaconda.network
+        (valid, err) = pyanaconda.network.sanityCheckHostname('_asf')
+        self.assertFalse(valid)
+
+    def sanity_check_hostname_5_test(self):
+        import pyanaconda.network
+        (valid, err) = pyanaconda.network.sanityCheckHostname('a?f')
+        self.assertFalse(valid)
+
+    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()
+        pyanaconda.network.socket = mock.Mock()
+        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,
+            pyanaconda.network.sanityCheckIPString, IPADDR)
+
+    def sanity_check_ip_string_4_test(self):
+        import pyanaconda.network
+        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
+        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,
+            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 = \
+            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 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',
+            '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()
+        self.assertEqual(nd.info, {})
+
+    def networkdevice_str_test(self):
+        import pyanaconda.network
+        pyanaconda.network.arch = mock.Mock()
+        pyanaconda.network.arch.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.assertIn('DEVICE="eth0"', str(nd))
+        self.assertIn('TYPE="Ethernet"', str(nd))
+
+    def networkdevice_load_ifcfg_file_test(self):
+        import pyanaconda.network
+        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
+        nd.loadIfcfgFile()
+        self.assertFalse(nd._dirty)
+        self.assertEqual(nd.info,
+            {'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.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)
+        nd.set(('key', 'value'))
+        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)
+        nd.set(('key', 'value'))
+        nd._dirty = False
+        nd.set(('key', 'other_value'))
+        self.assertEqual(nd.info, {'KEY': 'other_value'})
+        self.assertTrue(nd._dirty)
+
+    def networkdevice_set_gateway_test(self):
+        import pyanaconda.network
+        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
+        nd.setGateway('10.0.0.1')
+        self.assertEqual(nd.info, {'GATEWAY': '10.0.0.1'})
+        self.assertTrue(nd._dirty)
+
+    def networkdevice_set_gateway_ipv6_test(self):
+        import pyanaconda.network
+        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
+        nd.setGateway('fe80::5675:d0ff:feac:4d3f')
+        self.assertEqual(nd.info, {'IPV6_DEFAULTGW': 'fe80::5675:d0ff:feac:4d3f'})
+        self.assertTrue(nd._dirty)
+
+    def networkdevice_set_dns_test(self):
+        import pyanaconda.network
+        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
+        nd.setDNS('10.0.0.1, 10.0.0.2')
+        self.assertEqual(nd.info, {'DNS1': '10.0.0.1'})
+        self.assertEqual(nd.info, {'DNS2': '10.0.0.2'})
+        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'
+        TMP_DIR = '/tmp/wepkeyfiles'
+        pyanaconda.network.tempfile = mock.Mock()
+        pyanaconda.network.tempfile.mkstemp.return_value = (88, TMP_FILE)
+        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 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,
+            [('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,
+            [('set', (('NM_CONTROLLED', 'no'),), {})])
+
+    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],
+            'network --device eth0 --bootproto dhcp --noipv6\n')
+
+    def network_wait_for_connection_1_test(self):
+        import pyanaconda.network
+        pyanaconda.network.dbus = mock.Mock()
+        pyanaconda.network.dbus.Interface().Get.return_value = \
+            pyanaconda.network.isys.NM_STATE_CONNECTED_GLOBAL
+
+        ret = pyanaconda.network.waitForConnection()
+        self.assertTrue(ret)
+
+    def network_wait_for_connection_2_test(self):
+        import pyanaconda.network
+        pyanaconda.network.dbus = mock.Mock()
+        pyanaconda.network.dbus.Interface().Get.return_value = self.OK-5
+        pyanaconda.network.isys = mock.Mock()
+        pyanaconda.network.isys.NM_STATE_CONNECTED = self.OK
+        pyanaconda.network.time.sleep = mock.Mock()
+
+        ret = pyanaconda.network.waitForConnection()
+        self.assertFalse(ret)
+
+    def network_bring_up_test(self):
+        import pyanaconda.network
+        pyanaconda.network.Network.write = mock.Mock()
+        pyanaconda.network.waitForConnection = mock.Mock()
+
+        nw = pyanaconda.network.Network()
+        nw.bringUp()
+        self.assertTrue(pyanaconda.network.Network.write.called)
+        self.assertTrue(pyanaconda.network.waitForConnection.called)
+
+    def iface_for_host_ip_test(self):
+        import pyanaconda.network
+        pyanaconda.network.arch = mock.Mock()
+        pyanaconda.network.arch.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/old_tests/pyanaconda_test/packages_test.py b/old_tests/pyanaconda_test/packages_test.py
new file mode 100644
index 0000000..18de7ab
--- /dev/null
+++ b/old_tests/pyanaconda_test/packages_test.py
@@ -0,0 +1,25 @@
+#!/usr/bin/python
+
+import mock
+
+class PackagesTest(mock.TestCase):
+    
+    def setUp(self):
+        self.setupModules(["_isys", "block", "logging", "parted", "storage", 
+                    "pyanaconda.storage.formats", "ConfigParser", 
+                    "pyanaconda.storage.storage_log"])
+        self.fs = mock.DiskIO()
+        
+        import pyanaconda
+        pyanaconda.anaconda_log = mock.Mock()
+
+        import pyanaconda.packages
+        
+    def tearDown(self):
+        self.tearDownModules()
+    
+    def do_post_action_test(self):
+        import pyanaconda.packages
+        anaconda = mock.Mock()
+        pyanaconda.packages.doPostAction(anaconda)
+        self.assertTrue(anaconda.instClass.postAction.called)
diff --git a/old_tests/pyanaconda_test/packaging_test.py b/old_tests/pyanaconda_test/packaging_test.py
new file mode 100644
index 0000000..99bc871
--- /dev/null
+++ b/old_tests/pyanaconda_test/packaging_test.py
@@ -0,0 +1,126 @@
+#!/usr/bin/python
+
+import mock
+
+class PackagingTest(mock.TestCase):
+    
+    def setUp(self):
+        self.setupModules(["_isys", "logging"])
+        
+        import pyanaconda
+        pyanaconda.anaconda_log = mock.Mock()
+
+        from pykickstart.version import makeVersion
+        from pyanaconda.flags import flags
+
+        # set some things specially since we're just testing
+        flags.testing = True
+
+        # set up ksdata
+        self.ksdata = makeVersion()
+
+        from pyanaconda.packaging import Payload
+        self.payload = Payload(self.ksdata)
+
+    def tearDown(self):
+        self.tearDownModules()
+        #os.system("rm -rf %s" % self.root)
+
+    def payload_abstract_test(self):
+        self.assertRaises(NotImplementedError, self.payload.setup, None)
+        self.assertRaises(NotImplementedError, self.payload.description, None)
+
+    def payload_repo_test(self):
+        # ksdata repo list initially empty
+        self.assertEqual(self.payload.data.repo.dataList(), [])
+
+        # create and add a new ksdata repo
+        repo_name = "test1"
+        repo = self.ksdata.RepoData(name=repo_name, baseurl="http://localhost/")
+        self.payload.addRepo(repo)
+
+        # verify the repo was added
+        self.assertEqual(self.payload.data.repo.dataList(), [repo])
+        self.assertEqual(self.payload.getAddOnRepo(repo_name), repo)
+
+        # remove the repo
+        self.payload.removeRepo(repo_name)
+
+        # verify the repo was removed
+        self.assertEqual(self.payload.getAddOnRepo(repo_name), None)
+
+    def payload_group_test(self):
+        import pykickstart.constants
+        from pykickstart.parser import Group
+
+        # verify that ksdata group lists are initially empty
+        self.assertEqual(self.payload.data.packages.groupList, [])
+        self.assertEqual(self.payload.data.packages.excludedGroupList, [])
+
+        self.payload.deselectGroup("core")
+        self.assertEqual(self.payload.groupSelected("core"), False)
+
+        # select a group and verify the selection is reflected afterward
+        self.payload.selectGroup("core", optional=True)
+        self.assertTrue(self.payload.groupSelected("core"))
+
+        # verify the group is not in the excluded group list
+        self.assertTrue(Group("core") not in self.payload.data.packages.excludedGroupList)
+
+        # verify the include (optional/all) is recorded
+        groups = self.payload.data.packages.groupList
+        group = groups[[g.name for g in groups].index("core")]
+        self.assertEqual(group.include, pykickstart.constants.GROUP_ALL)
+
+        # select more groups
+        self.payload.selectGroup("base")
+        self.payload.selectGroup("development", default=False)
+
+        # verify include types for newly selected groups
+        group = groups[[g.name for g in groups].index("development")]
+        self.assertEqual(group.include, pykickstart.constants.GROUP_REQUIRED)
+
+        group = groups[[g.name for g in groups].index("base")]
+        self.assertEqual(group.include, pykickstart.constants.GROUP_DEFAULT)
+
+        # deselect a group and verify the set of groups is correct afterward
+        self.payload.deselectGroup("base")
+        self.assertFalse(self.payload.groupSelected("base"))
+        self.assertTrue(self.payload.groupSelected("core"))
+        self.assertTrue(self.payload.groupSelected("development"))
+
+    def payload_package_test(self):
+        # verify that ksdata package lists are initially empty
+        self.assertEqual(self.payload.data.packages.packageList, [])
+        self.assertEqual(self.payload.data.packages.excludedList, [])
+
+        name = "vim-common"
+
+        # deselect a package
+        self.payload.deselectPackage(name)
+        self.assertEqual(self.payload.packageSelected(name), False)
+
+        # select the same package and verify it
+        self.payload.selectPackage(name)
+        self.assertEqual(self.payload.packageSelected(name), True)
+        self.assertTrue(name in self.payload.data.packages.packageList)
+        self.assertFalse(name in self.payload.data.packages.excludedList)
+
+        # select some other packages
+        self.payload.selectPackage("bash")
+        self.payload.selectPackage("gnote")
+
+        # deselect one of them and then verify the selection state of them all
+        self.payload.deselectPackage("bash")
+        self.assertFalse(self.payload.packageSelected("bash"))
+        self.assertTrue(self.payload.packageSelected("gnote"))
+        self.assertTrue(self.payload.packageSelected(name))
+
+    def payload_get_release_version_test(self):
+        # Given no URL, _getReleaseVersion should be able to get a releasever
+        # from pyanaconda.constants.productVersion. This trickery is due to the
+        # fact that pyanaconda/packaging/__init__.py will have already imported
+        # productVersion from pyanaconda.constants.
+        import pyanaconda.packaging
+        pyanaconda.packaging.productVersion = "17-Beta"
+        self.assertEqual(self.payload._getReleaseVersion(None), "17")
diff --git a/old_tests/pyanaconda_test/partintfhelpers_test.py b/old_tests/pyanaconda_test/partintfhelpers_test.py
new file mode 100644
index 0000000..efc0680
--- /dev/null
+++ b/old_tests/pyanaconda_test/partintfhelpers_test.py
@@ -0,0 +1,480 @@
+#!/usr/bin/python
+
+import mock
+
+class PartIntfHelpersTest(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.partIntfHelpers
+          
+    def tearDown(self):
+        self.tearDownModules()
+
+    # sanityCheckVolumeGroupName tests
+
+    def sanitycheckvolumegroupname_right_hostname_1_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = "hostname"
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_right_hostname_2_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = "h"
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_right_hostname_3_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = "a" * 127
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_right_hostname_4_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = "h-o_s-t.name"
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_empty_hostname_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = ""
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_long_hostname_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = "asdfasdfas" * 13
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_1_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = 'lvm'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_2_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = 'root'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_3_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = '.'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_4_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = '..'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_5_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = 'foo bar'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckvolumegroupname_bad_hostname_6_test(self):
+        import pyanaconda.partIntfHelpers
+        HOSTNAME = 'foob at r'
+        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
+        self.assertNotEqual(ret, None)
+    
+    # sanityCheckLogicalVolumeName test
+    
+    def sanitychecklogicalvolumename_right_name_1_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "name"
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_right_name_2_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "name_00.9"
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_right_name_3_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "a"
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_empty_name_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = ""
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_long_name_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "b" * 129
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_bad_name_1_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "group"
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_bad_name_2_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = "."
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_bad_name_3_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = ".."
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_bad_name_4_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = 'foo bar'
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    def sanitychecklogicalvolumename_bad_name_5_test(self):
+        import pyanaconda.partIntfHelpers
+        LOGVOLNAME = 'foob at r'
+        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
+        self.assertNotEqual(ret, None)
+    
+    # sanityCheckMountPoint test
+    
+    def sanitycheckmountpoint_right_name_1_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/foob at r'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckmountpoint_right_name_2_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/var'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckmountpoint_right_name_3_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertEqual(ret, None)
+    
+    def sanitycheckmountpoint_bad_name_1_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '//'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+        
+    def sanitycheckmountpoint_bad_name_2_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/foo bar'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckmountpoint_bad_name_3_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/./'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckmountpoint_bad_name_4_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/../'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckmountpoint_bad_name_5_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/..'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+    
+    def sanitycheckmountpoint_bad_name_6_test(self):
+        import pyanaconda.partIntfHelpers
+        MNTPT = '/.'
+        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
+        self.assertNotEqual(ret, None)
+    
+    def dodeletedevice_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        STORAGE = mock.Mock()
+        DEVICE = None
+        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
+        self.assertFalse(ret)
+    
+    def dodeletedevice_2_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        STORAGE = mock.Mock()
+        STORAGE.deviceImmutable.return_value = True
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
+        self.assertFalse(ret)
+    
+    def dodeletedevice_3_test(self):
+        import pyanaconda.partIntfHelpers
+        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=False)
+        INTF = mock.Mock()
+        STORAGE = mock.Mock()
+        STORAGE.deviceImmutable.return_value = False
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
+        self.assertFalse(ret)
+    
+    def dodeletedevice_4_test(self):
+        import pyanaconda.partIntfHelpers
+        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=False)
+        INTF = mock.Mock()
+        STORAGE = mock.Mock()
+        STORAGE.deviceImmutable.return_value = False
+        STORAGE.deviceDeps.return_value = []
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE,
+                                                        confirm=0)
+        self.assertTrue(ret)
+        self.assertTrue(STORAGE.destroyDevice.called)
+    
+    def dodeletedevice_5_test(self):
+        import pyanaconda.partIntfHelpers
+        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=True)
+        INTF = mock.Mock()
+        STORAGE = mock.Mock()
+        STORAGE.deviceImmutable.return_value = False
+        STORAGE.deviceDeps.return_value = []
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
+        self.assertTrue(ret)
+        self.assertTrue(STORAGE.destroyDevice.called)
+    
+    def doclearpartitioneddevice_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = 0
+        STORAGE = mock.Mock()
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
+                                                                  DEVICE)
+        self.assertFalse(ret)
+    
+    def doclearpartitioneddevice_2_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = 1
+        STORAGE = mock.Mock()
+        STORAGE.partitions = []
+        DEVICE = mock.Mock()
+        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
+                                                                  DEVICE)
+        self.assertFalse(ret)
+    
+    def doclearpartitioneddevice_3_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = 1
+        DEVICE = mock.Mock()
+        p = mock.Mock()
+        p.disk = DEVICE
+        p.partedPartition.number = 0
+        STORAGE = mock.Mock()
+        STORAGE.partitions = [p]
+        STORAGE.deviceImmutable.return_value = False
+        STORAGE.deviceDeps.return_value = []
+        
+        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
+                                                                  DEVICE)
+        self.assertTrue(ret)
+    
+    def checkforswapnomatch_test(self):
+        import pyanaconda.partIntfHelpers
+        pyanaconda.partIntfHelpers.parted.PARTITION_SWAP = 5
+        device = mock.Mock()
+        device.exists.return_value = True
+        device.getFlag.return_value = True
+        device.format.type == "swap"
+        ANACONDA = mock.Mock()
+        ANACONDA.storage.partitions = [device]
+        ANACONDA.intf.messageWindow.return_value = 1
+        pyanaconda.partIntfHelpers.checkForSwapNoMatch(ANACONDA)
+        self.assertTrue(ANACONDA.storage.formatDevice.called)
+    
+    def musthaveselecteddrive_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        pyanaconda.partIntfHelpers.mustHaveSelectedDrive(INTF)
+        self.assertTrue(INTF.messageWindow.called)
+    
+    def querynoformatpreexisting_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 22
+        INTF = mock.Mock()
+        ret = INTF.messageWindow.return_value = RET
+        self.assertEqual(RET, ret)
+    
+    def partitionsanityerrors_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        ERRORS = []
+        ret = pyanaconda.partIntfHelpers.partitionSanityErrors(INTF, ERRORS)
+        self.assertEqual(1, ret)
+    
+    def partitionsanityerrors_2_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 5
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        ERRORS = ['err string', 'foo string']
+        ret = pyanaconda.partIntfHelpers.partitionSanityErrors(INTF, ERRORS)
+        self.assertEqual(RET, ret)
+        self.assertTrue(ERRORS[0] in INTF.messageWindow.call_args[0][1])
+        self.assertTrue(ERRORS[1] in INTF.messageWindow.call_args[0][1])
+    
+    def partitionsanitywarnings_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        WARNINGS = []
+        ret = pyanaconda.partIntfHelpers.partitionSanityWarnings(INTF, WARNINGS)
+        self.assertEqual(1, ret)
+    
+    def partitionsanitywarnings_2_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 5
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        WARNINGS = ['warning string', 'foo string']
+        ret = pyanaconda.partIntfHelpers.partitionSanityWarnings(INTF, WARNINGS)
+        self.assertEqual(RET, ret)
+        self.assertTrue(WARNINGS[0] in INTF.messageWindow.call_args[0][1])
+        self.assertTrue(WARNINGS[1] in INTF.messageWindow.call_args[0][1])
+    
+    def partitionpreexistformatwarnings_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        WARNINGS = []
+        ret = pyanaconda.partIntfHelpers.partitionPreExistFormatWarnings(INTF, WARNINGS)
+        self.assertEqual(1, ret)
+    
+    def partitionpreexistformatwarnings_2_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 10
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        WARNINGS = [('foo', 'foobar', '/foodir')]
+        ret = pyanaconda.partIntfHelpers.partitionPreExistFormatWarnings(INTF, WARNINGS)
+        self.assertEqual(RET, ret)
+        self.assertTrue(WARNINGS[0][0] in INTF.messageWindow.call_args[0][1])
+    
+    def getpreexistformatwarnings_1_test(self):
+        import pyanaconda.partIntfHelpers
+        STORAGE = mock.Mock()
+        STORAGE.devicetree.devices = []
+        ret = pyanaconda.partIntfHelpers.getPreExistFormatWarnings(STORAGE)
+        self.assertEqual([], ret)
+    
+    def getpreexistformatwarnings_2_test(self):
+        import pyanaconda.partIntfHelpers
+        STORAGE = mock.Mock()
+        device = mock.Mock()
+        device.exists = True
+        device.name = 'foodev'
+        device.path = '/foodevdir'
+        device.format.name = 'fffoodev'
+        device.format.mountpoint = '/mnt/foo'
+        device.format.exists = False
+        device.format.hidden = False
+        STORAGE.devicetree.devices = [device]
+        ret = pyanaconda.partIntfHelpers.getPreExistFormatWarnings(STORAGE)
+        self.assertEqual([('/foodevdir', 'fffoodev', '/mnt/foo')], ret)
+    
+    def confirmdelete_1_test(self):
+        import pyanaconda.partIntfHelpers
+        INTF = mock.Mock()
+        DEVICE = False
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(None, ret)
+    
+    def confirmdelete_2_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 51
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        DEVICE = mock.Mock()
+        DEVICE.type = "lvmvg"
+        DEVICE.name = "devname"
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(RET, ret)
+        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
+    
+    def confirmdelete_3_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 52
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        DEVICE = mock.Mock()
+        DEVICE.type = "lvmlv"
+        DEVICE.name = "devname"
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(RET, ret)
+        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
+    
+    def confirmdelete_4_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 53
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        DEVICE = mock.Mock()
+        DEVICE.type = "mdarray"
+        DEVICE.name = "devname"
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(RET, ret)
+    
+    def confirmdelete_5_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 54
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        DEVICE = mock.Mock()
+        DEVICE.type = "partition"
+        DEVICE.name = "devname"
+        DEVICE.path = "/dev/devname"
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(RET, ret)
+        self.assertTrue(DEVICE.path in INTF.messageWindow.call_args[0][1])
+    
+    def confirmdelete_6_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 55
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        DEVICE = mock.Mock()
+        DEVICE.type = "other"
+        DEVICE.name = "devname"
+        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
+        self.assertEqual(RET, ret)
+        self.assertTrue(DEVICE.type in INTF.messageWindow.call_args[0][1])
+        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
+    
+    def confirmresetpartitionstate_test(self):
+        import pyanaconda.partIntfHelpers
+        RET = 61
+        INTF = mock.Mock()
+        INTF.messageWindow.return_value = RET
+        ret = pyanaconda.partIntfHelpers.confirmResetPartitionState(INTF)
+        self.assertEqual(RET, ret)
+    
diff --git a/old_tests/pyanaconda_test/product_test.py b/old_tests/pyanaconda_test/product_test.py
new file mode 100644
index 0000000..9b0d864
--- /dev/null
+++ b/old_tests/pyanaconda_test/product_test.py
@@ -0,0 +1,82 @@
+#!/usr/bin/python
+
+import mock
+import sys
+import __builtin__
+
+import ConfigParser
+
+class ProductTest(mock.TestCase):
+
+    def setUp(self):
+        self.setupModules(['_isys', 'block', 'os'])
+        self.fs = mock.DiskIO()
+
+        # 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 = {}
+
+        # fake /tmp/product/.buildstamp file
+        self.BUGURL = 'http://bug.url'
+        self.FINAL = 'false'
+        self.ARCH = 'i386'
+        self.NAME = '__anaconda'
+        self.UUID = '123456.%s' % self.ARCH
+        self.VERSION = '14'
+        self.FILENAME = '/tmp/product/.buildstamp'
+        self.FILE = \
+        "[Main]\n"\
+        "BugURL: %s\n"\
+        "IsFinal: %s\n"\
+        "Arch: %s\n"\
+        "Product: %s\n"\
+        "UUID: %s\n"\
+        "Version: %s\n" % \
+        (self.BUGURL, self.FINAL, 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
+
+        if 'pyanaconda.product' in sys.modules:
+            del(sys.modules["pyanaconda.product"])
+
+    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_final_test(self):
+        sys.modules['os'].access = mock.Mock(return_value=True)
+        import pyanaconda.product
+        self.assertFalse(pyanaconda.product.isFinal)
+
+    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
+        self.assertEqual(pyanaconda.product.productName, self.NAME)
+
+    def product_stamp_test(self):
+        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
+        self.assertEqual(pyanaconda.product.productVersion, self.VERSION)
+
diff --git a/old_tests/pyanaconda_test/rescue_test.py b/old_tests/pyanaconda_test/rescue_test.py
new file mode 100644
index 0000000..b93f75e
--- /dev/null
+++ b/old_tests/pyanaconda_test/rescue_test.py
@@ -0,0 +1,297 @@
+#!/usr/bin/python
+
+import mock
+
+class RescueTest(mock.TestCase):
+
+    def setUp(self):
+        self.setupModules(
+            ['_isys', 'block', 'parted', 'storage', 'pyanaconda.storage.formats',
+             'logging', 'add_drive_text', 'ConfigParser',
+             'pyanaconda.storage.storage_log', 'pyanaconda.anaconda_log', 'snack'
+             ])
+
+        self.fs = mock.DiskIO()
+
+        import pyanaconda
+        pyanaconda.anaconda_log = mock.Mock()
+        import snack
+        snack.SnackScreen = mock.Mock()
+
+        import pyanaconda.rescue
+        pyanaconda.rescue.open = self.fs.open
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    #
+    # RescueInterface class tests
+    #
+
+    def rescueinterface_waitwindow_test(self):
+        import pyanaconda.rescue
+        RET = 'foo1'
+        pyanaconda.rescue.WaitWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.waitWindow(TITLE, TEXT)
+        self.assertEqual(ret, RET)
+
+    def rescueinterface_progresswindow_test(self):
+        import pyanaconda.rescue
+        RET = 'foo2'
+        pyanaconda.rescue.ProgressWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        TOTAL = 100
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.progressWindow(TITLE, TEXT, TOTAL)
+        self.assertEqual(ret, RET)
+
+    def rescueinterface_detailedmessagewindow_test(self):
+        import pyanaconda.rescue
+        RET = 'foo3'
+        pyanaconda.rescue.RescueInterface.messageWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.detailedMessageWindow(TITLE, TEXT)
+        self.assertEqual(ret, RET)
+
+    def rescueinterface_messagewindow_1_test(self):
+        import pyanaconda.rescue
+        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock()
+        TITLE = 'title'
+        TEXT = 'text'
+        TYPE = 'ok'
+        ri = pyanaconda.rescue.RescueInterface()
+        ri.detailedMessageWindow(TITLE, TEXT, TYPE)
+        self.assertTrue(pyanaconda.rescue.ButtonChoiceWindow.called)
+
+    def rescueinterface_messagewindow_2_test(self):
+        import pyanaconda.rescue
+        RET='yes'
+        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        TYPE = 'yesno'
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.messageWindow(TITLE, TEXT, TYPE)
+        self.assertEqual(ret, 1)
+
+    def rescueinterface_messagewindow_3_test(self):
+        import pyanaconda.rescue
+        RET = 'barfoo'
+        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        TYPE = 'custom'
+        CUSTOM_BUTT = ['foo_bar', 'bar_foo']
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.messageWindow(TITLE, TEXT, TYPE, custom_buttons=CUSTOM_BUTT)
+        self.assertEqual(ret, 1)
+
+    def rescueinterface_messagewindow_4_test(self):
+        import pyanaconda.rescue
+        RET = 'foo4'
+        pyanaconda.rescue.OkCancelWindow = mock.Mock(return_value=RET)
+        TITLE = 'title'
+        TEXT = 'text'
+        TYPE = 'otherfoo'
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.messageWindow(TITLE, TEXT, TYPE)
+        self.assertEqual(ret, RET)
+
+    def rescueinterface_enablenetwork_1_test(self):
+        import pyanaconda.rescue
+        anaconda = mock.Mock()
+        anaconda.network.netdevices = {}
+
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.enableNetwork(anaconda)
+        self.assertFalse(ret)
+
+    def rescueinterface_passphraseentrywindow_test(self):
+        import pyanaconda.rescue
+        RET = ('secret', False)
+        pyanaconda.rescue.PassphraseEntryWindow = mock.Mock()
+        pyanaconda.rescue.PassphraseEntryWindow().run.return_value = RET
+        DEVICE = 'dev'
+
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.passphraseEntryWindow(DEVICE)
+        self.assertEqual(ret, RET)
+        self.assertTrue(pyanaconda.rescue.PassphraseEntryWindow().pop.called)
+
+    def rescueinterface_resetinitializediskquestion_test(self):
+        import pyanaconda.rescue
+        ri = pyanaconda.rescue.RescueInterface()
+        ri._initLabelAnswers = {'foo': 'bar'}
+        ri.resetInitializeDiskQuestion()
+
+    def rescueinterface_resetreinitinconsistentlvmquestion_test(self):
+        import pyanaconda.rescue
+        ri = pyanaconda.rescue.RescueInterface()
+        ri._inconsistentLVMAnswers = {'foo': 'bar'}
+        ri.resetReinitInconsistentLVMQuestion()
+        self.assertEqual(ri._inconsistentLVMAnswers, {})
+
+    def rescueinterface_questioninitializedisk_test(self):
+        import pyanaconda.rescue
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.questionInitializeDisk('/', '', 0)
+        self.assertFalse(ret)
+
+    def rescueinterface_questionreinitinconsistentlvm_test(self):
+        import pyanaconda.rescue
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.questionReinitInconsistentLVM()
+        self.assertFalse(ret)
+
+    def rescueinterface_questioninitializedasd_test(self):
+        import pyanaconda.rescue
+        ri = pyanaconda.rescue.RescueInterface()
+        ret = ri.questionInitializeDASD('', '')
+        self.assertEqual(ret, 1)
+
+    #
+    # module function tests
+    #
+
+    def makefstab_test(self):
+        import pyanaconda.rescue
+        INSTPATH = '/tmp'
+        FSTAB = 'rootfs / rootfs rw 0 0'
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.access.return_value = True
+        self.fs.open('/proc/mounts', 'w').write(FSTAB)
+        self.fs.open('%s/etc/fstab' % INSTPATH, 'w')
+
+        ret = pyanaconda.rescue.makeFStab(INSTPATH)
+        self.assertEqual(self.fs['%s/etc/fstab' % INSTPATH], FSTAB)
+
+    def makeresolvconf_1_test(self):
+        import pyanaconda.rescue
+        INSTPATH = '/tmp'
+        RESOLV = "nameserver 10.0.0.1"
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.access.return_value = False
+        pyanaconda.rescue.shutil = mock.Mock()
+
+        pyanaconda.rescue.makeResolvConf(INSTPATH)
+        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
+
+    def makeresolvconf_2_test(self):
+        import pyanaconda.rescue
+        INSTPATH = '/tmp'
+        RESOLV = "nameserver 10.0.0.1"
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.access.return_value = True
+        pyanaconda.rescue.shutil = mock.Mock()
+        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write(RESOLV)
+
+        pyanaconda.rescue.makeResolvConf(INSTPATH)
+        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
+
+    def makeresolvconf_3_test(self):
+        import pyanaconda.rescue
+        INSTPATH = '/tmp'
+        RESOLV = "nameserver 10.0.0.1"
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.access.return_value = True
+        pyanaconda.rescue.shutil = mock.Mock()
+        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write('')
+        self.fs.open('/etc/resolv.conf', 'w').write('')
+
+        pyanaconda.rescue.makeResolvConf(INSTPATH)
+        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
+        self.assertEqual(self.fs['%s/etc/resolv.conf' % INSTPATH], '')
+
+    def makeresolvconf_4_test(self):
+        import pyanaconda.rescue
+        INSTPATH = '/tmp'
+        RESOLV = "nameserver 10.0.0.1"
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.access.return_value = True
+        pyanaconda.rescue.shutil = mock.Mock()
+        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write('')
+        self.fs.open('/etc/resolv.conf', 'w').write(RESOLV)
+
+        pyanaconda.rescue.makeResolvConf(INSTPATH)
+        self.assertTrue(pyanaconda.rescue.shutil.copyfile.called)
+        self.assertEqual(self.fs['%s/etc/resolv.conf' % INSTPATH],
+            'nameserver 10.0.0.1')
+
+    def startnetworking_test(self):
+        import pyanaconda.rescue
+        NETWORK = mock.Mock()
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.startNetworking(NETWORK, '')
+        self.assertEqual(pyanaconda.rescue.os.system.call_args,
+            (('/usr/sbin/ifconfig lo 127.0.0.1',), {}))
+        self.assertTrue(NETWORK.bringUp.called)
+
+    def runshell_1_test(self):
+        import pyanaconda.rescue
+        import sys
+        TMPFILE = '/tmp/abc'
+        MSG = "foo bar"
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.path.exists.return_value = True
+        pyanaconda.rescue.subprocess = mock.Mock()
+        proc = mock.Mock()
+        proc.returncode = 0
+        pyanaconda.rescue.subprocess.Popen.return_value = proc
+
+        stdout = sys.stdout
+        sys.stdout = self.fs.open(TMPFILE, 'w')
+        pyanaconda.rescue.runShell(msg=MSG)
+        sys.stdout.close()
+        sys.stdout = stdout
+
+        self.assertTrue(MSG in self.fs[TMPFILE])
+        self.assertEqual(pyanaconda.rescue.subprocess.Popen.call_args,
+            ((['/usr/bin/firstaidkit-qs'],), {}))
+
+    def runshell_2_test(self):
+        import pyanaconda.rescue
+        import sys
+        TMPFILE = '/tmp/abc'
+        MSG = "foo bar"
+
+        def fake_f(filename, _=""):
+            return filename == "/bin/bash"
+
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.path.exists = fake_f
+        pyanaconda.rescue.iutil = mock.Mock()
+        proc = mock.Mock()
+        proc.returncode = 0
+        pyanaconda.rescue.subprocess.Popen.return_value = proc
+
+        stdout = sys.stdout
+        sys.stdout = self.fs.open(TMPFILE, 'w')
+        pyanaconda.rescue.runShell(msg=MSG)
+        sys.stdout.close()
+        sys.stdout = stdout
+
+        self.assertTrue(MSG in self.fs[TMPFILE])
+        self.assertTrue(pyanaconda.rescue.iutil.execConsole.called)
+
+    def runshell_3_test(self):
+        import pyanaconda.rescue
+        import sys
+        TMPFILE = '/tmp/abc'
+        SCREEN = mock.Mock()
+        pyanaconda.rescue.os = mock.Mock()
+        pyanaconda.rescue.os.path.exists.return_value = True
+        pyanaconda.rescue.subprocess = mock.Mock()
+        proc = mock.Mock()
+        proc.returncode = 0
+        pyanaconda.rescue.subprocess.Popen.return_value = proc
+
+        pyanaconda.rescue.runShell(screen=SCREEN)
+
+        self.assertTrue(SCREEN.suspend.called)
+        self.assertTrue(SCREEN.finish.called)
diff --git a/old_tests/pyanaconda_test/security_test.py b/old_tests/pyanaconda_test/security_test.py
new file mode 100644
index 0000000..33b94c1
--- /dev/null
+++ b/old_tests/pyanaconda_test/security_test.py
@@ -0,0 +1,62 @@
+#!/usr/bin/python
+
+import mock
+import sys
+
+class SecurityTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])
+
+        self.fs = mock.DiskIO()
+
+        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
+        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_test(self):
+        """Simulate writing security (simulate executing lokkit and authconfig)"""
+        import pyanaconda.security
+
+        scrt = pyanaconda.security.Security()
+        pyanaconda.security.ROOT_PATH = "/tmp/security"
+        scrt.write()
+
+        self.assertEqual(pyanaconda.security.iutil.method_calls,
+            [('execWithRedirect',
+                ('/usr/sbin/lokkit', ['--selinux=enforcing']),
+                {'root': '/tmp/security', 'stderr': '/dev/null', 'stdout': '/dev/null'}
+             ),
+             ('resetRpmDb', (), {}),
+             ('execWithRedirect',
+                ('/usr/sbin/authconfig',
+                    ['--update', '--nostart', '--enableshadow', '--passalgo=sha512']
+                ),
+                {'root': '/tmp/security', 'stderr': '/dev/tty5', 'stdout': '/dev/tty5'}
+             )
+            ]
+        )
diff --git a/old_tests/pyanaconda_test/simpleconfig_test.py b/old_tests/pyanaconda_test/simpleconfig_test.py
new file mode 100644
index 0000000..265ed88
--- /dev/null
+++ b/old_tests/pyanaconda_test/simpleconfig_test.py
@@ -0,0 +1,154 @@
+#!/usr/bin/python
+
+import mock
+import os
+import sys
+
+class SimpleconfigTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])
+        import pyanaconda.simpleconfig
+
+        # Stuff for IfcfgFile class tests
+        self.DIR = '/tmp/'
+        self.IFACE = 'eth0'
+        self.PATH = "%sifcfg-%s" % (self.DIR, self.IFACE)
+        self.CONTENT = '# Broadcom Corporation NetXtreme BCM5761 Gigabit Ethernet\n'
+        self.CONTENT += 'DEVICE=eth0\n'
+        self.CONTENT += 'HWADDR=00:10:18:61:35:98\n'
+        self.CONTENT += 'ONBOOT=no\n'
+        open(self.PATH, 'w').write(self.CONTENT)
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def uppercase_ascii_string_letters_test(self):
+        """Converting to uppercase (letters)"""
+        import pyanaconda.simpleconfig
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('abcd')
+        self.assertEqual(ret, 'ABCD')
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('aBCD')
+        self.assertEqual(ret, 'ABCD')
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('ABCD')
+        self.assertEqual(ret, 'ABCD')
+
+    def uppercase_ascii_string_numbers_test(self):
+        """Converting to uppercase (numbers)"""
+        import pyanaconda.simpleconfig
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('123')
+        self.assertEqual(ret, '123')
+
+    def uppercase_ascii_string_others_test(self):
+        """Converting to uppercase (special chars)"""
+        import pyanaconda.simpleconfig
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('--')
+        self.assertEqual(ret, '--')
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string(' ')
+        self.assertEqual(ret, ' ')
+        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('')
+        self.assertEqual(ret, '')
+
+    def unquote_test(self):
+        from pyanaconda.simpleconfig import unquote
+        self.assertEqual(unquote("plain string"), "plain string")
+        self.assertEqual(unquote('"double quote"'), "double quote")
+        self.assertEqual(unquote("'single quote'"), "single quote")
+
+    def quote_test(self):
+        from pyanaconda.simpleconfig import quote
+        self.assertEqual(quote("nospaces"), "nospaces")
+        self.assertEqual(quote("plain string"), '"plain string"')
+        self.assertEqual(quote("alwaysquote", always=True), '"alwaysquote"')
+
+    def set_and_get_test(self):
+        """Setting and getting values"""
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.SimpleConfigFile()
+        scf.set(('key1', 'value1'))
+        self.assertEqual(scf.get('key1'), 'value1')
+        scf.set(('KEY2', 'value2'))
+        self.assertEqual(scf.get('key2'), 'value2')
+        scf.set(('KEY3', 'value3'))
+        self.assertEqual(scf.get('KEY3'), 'value3')
+        scf.set(('key4', 'value4'))
+        self.assertEqual(scf.get('KEY4'), 'value4')
+
+    def unset_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.SimpleConfigFile()
+        scf.set(('key1', 'value1'))
+        scf.unset(('key1'))
+        self.assertEqual(scf.get('key1'), '')
+
+    def write_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.SimpleConfigFile()
+        scf.set(('key1', 'value1'))
+        scf.write('/tmp/file')
+        self.assertEqual(open('/tmp/file').read(), 'KEY1=value1\n')
+
+    def read_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.SimpleConfigFile()
+        open('/tmp/file', 'w').write('KEY1="value1"\n')
+        scf.read('/tmp/file')
+        self.assertEqual(scf.get('key1'), 'value1')
+
+    def read_write_test(self):
+        from pyanaconda.simpleconfig import SimpleConfigFile
+        scf = SimpleConfigFile()
+        scf.read(self.PATH)
+        scf.write("/tmp/file")
+        self.assertEqual(open("/tmp/file").read(), self.CONTENT)
+
+    def write_new_keys_test(self):
+        from pyanaconda.simpleconfig import SimpleConfigFile
+        scf = SimpleConfigFile()
+        scf.read(self.PATH)
+        scf.set(("key1", "value1"))
+        scf.write("/tmp/file")
+        self.assertEqual(open("/tmp/file").read(),
+                         self.CONTENT+"KEY1=value1\n")
+
+    def remove_key_test(self):
+        from pyanaconda.simpleconfig import SimpleConfigFile
+        scf = SimpleConfigFile()
+        scf.read(self.PATH)
+        scf.unset("BOOT")
+        scf.write("/tmp/file")
+        scf.reset()
+        scf.read("/tmp/file")
+        self.assertEqual(scf.get("BOOT"), "")
+
+    def ifcfgfile_path_property_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
+        self.assertEqual(scf.path, self.PATH)
+
+    def ifcfgfile_read_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
+        scf.read()
+        self.assertEqual(scf.get('device'), 'eth0')
+        self.assertEqual(scf.get('hwaddr'), '00:10:18:61:35:98')
+        self.assertEqual(scf.get('onboot'), 'no')
+
+    def ifcfgfile_read_and_clear_test(self):
+        import pyanaconda.simpleconfig        
+        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
+        scf.read()
+        scf.clear()
+        self.assertEqual(scf.get('device'), '')
+        self.assertEqual(scf.get('hwaddr'), '')
+        self.assertEqual(scf.get('onboot'), '')
+
+    def ifcfgfile_write_test(self):
+        import pyanaconda.simpleconfig
+        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
+        scf.set(('device', 'eth0'))
+        scf.set(('hwaddr', '00:11:22:33:44:55'))
+        scf.set(('onboot', 'no'))
+        scf.write()
+        self.assertEqual(open(self.PATH).read(),
+            'DEVICE="eth0"\nHWADDR="00:11:22:33:44:55"\nONBOOT="no"\n')
+
diff --git a/old_tests/pyanaconda_test/timezone_test.py b/old_tests/pyanaconda_test/timezone_test.py
new file mode 100644
index 0000000..a53f292
--- /dev/null
+++ b/old_tests/pyanaconda_test/timezone_test.py
@@ -0,0 +1,56 @@
+#!/usr/bin/python
+
+import mock
+import sys
+
+ZONE = 'Europe/Prague'
+UTC = 2
+
+class TimeZoneTest(mock.TestCase):
+    def setUp(self):
+        self.setupModules(["_isys", "block", "ConfigParser"])
+
+        self.fs = mock.DiskIO()
+
+        import pyanaconda.timezone
+        pyanaconda.timezone.log = mock.Mock()
+        pyanaconda.timezone.open = self.fs.open
+        pyanaconda.timezone.os.access = mock.Mock(return_value = True)
+        pyanaconda.timezone.shutil.copyfile = mock.Mock()
+        pyanaconda.timezone.os = mock.Mock()
+        pyanaconda.timezone.os.access.return_value = True
+        pyanaconda.timezone.shutil = mock.Mock()
+        #pyanaconda.timezone.shutil.copyfile = mock.Mock()
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def get_timezone_info_test(self):
+        import pyanaconda.timezone
+        tz = pyanaconda.timezone.Timezone()
+        info = tz.getTimezoneInfo()
+        self.assertEqual( (tz.tz, tz.utc), info )
+
+    def set_timezone_info_test(self):
+        import pyanaconda.timezone
+        tz = pyanaconda.timezone.Timezone()
+        tz.setTimezoneInfo(ZONE, UTC)
+        self.assertEqual((ZONE, UTC), (tz.tz, tz.utc))
+
+    def write_test(self):
+        import pyanaconda.timezone
+
+        tz = pyanaconda.timezone.Timezone()
+        tz.tz = ZONE
+        tz.utc = True
+
+        PATH = ''
+        ADJTIME = '0.013782 1279118821 0.000000\n1279118821\nUTC\n'
+        f = self.fs.open('/mnt/sysimage/etc/adjtime', 'w')
+        f.write(ADJTIME)
+        f.close()
+
+        tz.write()
+        self.assertEqual(self.fs['/mnt/sysimage/etc/adjtime'], ADJTIME)
+
+
diff --git a/old_tests/pyanaconda_test/users_test.py b/old_tests/pyanaconda_test/users_test.py
new file mode 100644
index 0000000..c457ef7
--- /dev/null
+++ b/old_tests/pyanaconda_test/users_test.py
@@ -0,0 +1,142 @@
+#!/usr/bin/python
+
+import mock
+import sys
+
+GIDNUMBER = 'pw_gid'
+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
+        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.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
+
+        GROUP = 'Group'
+        GID = 100
+        group_dict = {  "name" : GROUP,
+                        "gid" : GID,
+                        "root" : ""
+                    }
+
+        usr = pyanaconda.users.Users(self.anaconda)
+        self.assertTrue(usr.createGroup(GROUP, **group_dict))
+
+        methods = pyanaconda.users.libuser.admin().method_calls[:]
+        try:
+            if methods[2][0] == 'addGroup':
+                methods.pop()
+        except:
+            pass
+
+        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
+
+        USER = 'TestUser'
+        PASS = 'abcde'
+        user_dict = {   "name" : USER,
+                        "password" : PASS,
+                        "groups" : [],
+                        "homedir" : "",
+                        "isCrypted" : False,
+                        "shell" : "",
+                        "uid" : None,
+                        "root" : ""
+                    }
+
+        usr = pyanaconda.users.Users(self.anaconda)
+        self.assertTrue(usr.createUser(USER, **user_dict))
+
+        self.assertTrue(pyanaconda.users.iutil.mkdirChain.called)
+        methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
+
+        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', (HOMEDIRECTORY, '/home/%s' % USER), {})]
+        )
+
+        self.assertEqual(pyanaconda.users.libuser.admin().initGroup().method_calls,
+            [('get', (GIDNUMBER,), {})])
+
+    def check_user_exists_test(self):
+        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,), {})])
+
+    def get_pass_algo_md5_test(self):
+        import pyanaconda.users
+        usr = pyanaconda.users.Users(self.anaconda)
+        self.assertEqual(usr.getPassAlgo(), None)
+
+    def set_user_password_test(self):
+        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,
+            ['lookupUserByName', 'setpassUser', 'modifyUser'])
+
+    def set_root_password_test(self):
+        import pyanaconda.users
+
+        usr = pyanaconda.users.Users(self.anaconda)
+        usr.setRootPassword()
+        methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
+        self.assertEqual(methods,
+            ['lookupUserByName', 'setpassUser', 'modifyUser'])
diff --git a/old_tests/pyanaconda_test/vnc_test.py b/old_tests/pyanaconda_test/vnc_test.py
new file mode 100644
index 0000000..80cc527
--- /dev/null
+++ b/old_tests/pyanaconda_test/vnc_test.py
@@ -0,0 +1,116 @@
+#!/usr/bin/python
+
+import mock
+import os
+
+class VncTest(mock.TestCase):
+
+    def setUp(self):
+        self.setupModules(["_isys", "block", "logging", "ConfigParser"])
+        self.fs = mock.DiskIO()
+
+        self.anaconda = mock.Mock()
+        self.anaconda.ksdata.vnc.password = ''
+
+        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.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'
+        self.PASS = ''
+        self.LOG_FILE = '/tmp/vnc.log'
+        self.PW_FILE = '/tmp/vncpassword'
+        self.VNCCONNECTHOST = 'host'
+
+    def tearDown(self):
+        self.tearDownModules()
+
+    def set_vnc_password_1_test(self):
+        import pyanaconda.vnc
+        server = pyanaconda.vnc.VncServer()
+        server.anaconda = self.anaconda
+        pyanaconda.vnc.iutil = mock.Mock()
+        pyanaconda.vnc.os.pipe.return_value = (1, 2)
+
+        server.setVNCPassword()
+        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()
+        pyanaconda.vnc.network.Network().netdevices = [dev]
+        pyanaconda.vnc.network.getActiveNetDevs.return_value = [0]
+        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 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.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.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()
+        pyanaconda.vnc.VncServer.setVNCPassword = mock.Mock()
+        pyanaconda.vnc.VncServer.VNCListen = mock.Mock()
+        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)
diff --git a/old_tests/pylint/Makefile.am b/old_tests/pylint/Makefile.am
new file mode 100644
index 0000000..f934cf5
--- /dev/null
+++ b/old_tests/pylint/Makefile.am
@@ -0,0 +1,22 @@
+# tests/kickstart/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Chris Lumens <clumens at redhat.com>
+
+EXTRA_DIST = *pylint*
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/old_tests/pylint/pylint-false-positives b/old_tests/pylint/pylint-false-positives
new file mode 100644
index 0000000..97f566c
--- /dev/null
+++ b/old_tests/pylint/pylint-false-positives
@@ -0,0 +1,34 @@
+^F0002:[ 0-9]*: <type 'exceptions.RuntimeError'>: could not open display$
+^F0401:[ 0-9]*: Unable to import 'gtk.gdk'$
+^F0401:[ 0-9]*: Unable to import 'repomd.mdErrors'$
+^F0401:[ 0-9]*: Unable to import 'volume_key'$
+^E0601:[ 0-9]*:VolumeGroupEditor\.editLogicalVolume\.<lambda>: Using variable 'maintable' before assignment$
+^W0122:[ 0-9]*:InstallInterface\.run: Use of the exec statement$
+^E0602:[ 0-9]*:InstallInterface\.run: Undefined variable 'nextWin'$
+^E0602:[ 0-9]*:sparcBootloaderInfo\.writeSilo: Undefined variable 'butil'$
+^E0611:[ 0-9]*: No name '_isys' in module 'pyanaconda'$
+^E0611:[ 0-9]*:.*: No name '_isys' in module 'pyanaconda'$
+^E1101:[ 0-9]*:.*: Class 'vbox' has no 'pack_start' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'get_model' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'get_column' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'set_expander_column' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'append_row' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'store' member$
+^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'set_size_request' member$
+^E1101:[ 0-9]*:.*: Instance of '.*' has no 'anaconda' member$
+^E1101:[ 0-9]*:.*: Instance of 'AnacondaKSHandler' has no 'commands' member$
+^E1101:[ 0-9]*:AnacondaTZMap\.selectionChanged: Instance of 'Enum' has no 'ENTRY' member$
+^E1101:[ 0-9]*:DeviceAction\..*: Instance of 'DeviceAction' has no 'dir' member$
+^E1101:[ 0-9]*:VolumeGroupEditor\.editLogicalVolume: Class 'format' has no 'mountable' member$
+^E1101:[ 0-9]*:randomIname: Module 'hashlib' has no 'md5' member$
+^E1101:[ 0-9]*:rpm.*: Instance of 'TransactionSet' has no 'dbMatch' member$
+^E1101:[ 0-9]*:EntryWindow.__init__: Class 'child' has no 'pack_start' member$
+^E1101:[ 0-9]*:.*: Instance of 'dict' has no 'Get' member$
+^E1101:[ 0-9]*:FilteredCallbacks\..*set: Instance of 'FilteredCallbacks' has no 'notebook' member$
+^E1101:[ 0-9]*:Anaconda\.backend: Instance of 'DefaultInstall' has no 'getBackend' member$
+^W0404:[ 0-9]*:runRescue: Reimport 'runPostScripts' \(imported line [0-9]*\)$
+# Note this will become a real issue when we start supporting multiple netdevs
+^W0631:[ 0-9]*:Network.write: Using possibly undefined loop variable 'dev'$
+# Also filter out the stupid pyblock not running as root message
+^dm.c: [ 0-9]*: not running as root returning empty list$
+Note this last line must never end with a newline
\ No newline at end of file
diff --git a/old_tests/pylint/runpylint.sh b/old_tests/pylint/runpylint.sh
new file mode 100755
index 0000000..afd95fc
--- /dev/null
+++ b/old_tests/pylint/runpylint.sh
@@ -0,0 +1,108 @@
+#!/bin/bash
+
+# This script will check anaconda for any pylint warning and errors using a set
+# of options minimizing false positives, in combination with filtering of any
+# warning regularexpressions listed in pylint-false-positives.
+# 
+# If any warnings our found they will be stored in pylint-log and printed
+# to stdout and this script will exit with a status of 1, if no (non filtered)
+# warnings are found it exits with a status of 0
+
+FALSE_POSITIVES=tests/pylint/pylint-false-positives
+
+# W0107 - Unnecessary pass statement
+# W0108 - Lambda may not be necessary
+# W0212 - Access to a protected member %s of a client class
+# W0311 - Bad indentation. Found %s %s, expected %s
+# W0312 - Found indentation with %ss instead of %ss
+# W0402 - Uses of a deprecated module %r
+# W0611 - Unused import %s
+# W0612 - Unused variable %r
+# W0710 - Exception doesn't inherit from standard "Exception" class
+NON_STRICT_OPTIONS="--disable=W0107,W0108,W0212,W0311,W0312,W0402,W0611,W0612,W0710"
+
+# E1103 - %s %r has no %r member (but some types could not be inferred)
+DISABLED_ERR_OPTIONS="--disable=E1103"
+
+# W0102 - Dangerous default value %s as argument
+# W0141 - Used builtin function %r
+# W0142 - Used * or ** magic
+# W0201 - Attribute %r defined outside __init__
+# W0221 - Arguments number differs from %s method
+# W0223 - Method %r is abstract in class %r but is not overridden
+# W0231 - __init__ method from base class %r is not called
+# W0232 - Class has no __init__ method
+# W0233 - __init__ method from a non direct base class %r is called
+# W0401 - Wildcard import %s
+# W0403 - Relative import %r, should be %r
+# W0404 - Reimport %r (imported line %s)
+# W0511 - Used when a warning note as FIXME or XXX is detected.
+# W0602 - Using global for %r but no assignment is done
+# W0603 - Using the global statement
+# W0604 - Using the global statement at the module level
+# W0613 - Unused argument %r
+# W0614 - Unused import %s from wildcard import
+# W0621 - Redefining name %r from outer scope (line %s)
+# W0622 - Redefining built-in %r
+# W0702 - No exception type(s) specified
+# W0703 - Catch "Exception"
+# W1001 - Use of "property" on an old style class
+DISABLED_WARN_OPTIONS="--disable=W0102,W0141,W0142,W0201,W0221,W0223,W0231,W0232 \
+                       --disable=W0233,W0401,W0403,W0404,W0511,W0602,W0603,W0604 \
+                       --disable=W0613,W0614,W0621,W0622,W0702,W0703,W1001"
+
+usage () {
+  echo "usage: `basename $0` [--strict] [--help]"
+  exit $1
+}
+
+while [ $# -gt 0 ]; do
+  case $1 in
+    --strict)
+      NON_STRICT_OPTIONS=
+      ;;
+    --help)
+      usage 0
+      ;;
+    *)
+      echo "Error unknown option: $1"
+      usage 1
+  esac
+  shift
+done
+
+if [ "`tail -c 1 $FALSE_POSITIVES`" == "`echo`" ]; then
+  echo "Error $FALSE_POSITIVES ends with an enter."
+  echo "Error the last line of $FALSE_POSITIVES should never have an enter!"
+  exit 1
+fi
+
+# run pylint one file / module at a time, otherwise it sometimes gets
+# confused
+> pylint-log
+for i in $(find pyanaconda -type f -name '*py'); do
+  pylint --init-hook='import sys; \
+      sys.path.insert(1, "pyanaconda/isys/.libs"); \
+      sys.path.insert(2, "pyanaconda/isys"); \
+      sys.path.insert(3, "pyanaconda"); \
+      sys.path.insert(4, "pyanaconda/.libs")' \
+    -i y -r n --disable=C,R --rcfile=/dev/null \
+    $DISABLED_WARN_OPTIONS \
+    $DISABLED_ERR_OPTIONS \
+    $NON_STRICT_OPTIONS $i | \
+    egrep -v "`cat $FALSE_POSITIVES | tr '\n' '|'`" > pylint-tmp-log
+  if grep -q -v '************* Module ' pylint-tmp-log; then
+    cat pylint-tmp-log >> pylint-log
+  fi
+done
+rm pylint-tmp-log
+
+if [ -s pylint-log ]; then
+  echo "pylint reports the following issues:"
+  cat pylint-log
+  exit 1
+fi
+
+rm pylint-log
+
+exit 0
diff --git a/old_tests/regex/Makefile.am b/old_tests/regex/Makefile.am
new file mode 100644
index 0000000..af1bd58
--- /dev/null
+++ b/old_tests/regex/Makefile.am
@@ -0,0 +1,22 @@
+# tests/regex/Makefile.am for anaconda
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Brian C. Lane <bcl at redhat.com>
+
+EXTRA_DIST = *.py
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/old_tests/regex/__init__.py b/old_tests/regex/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/old_tests/regex/proxy_test.py b/old_tests/regex/proxy_test.py
new file mode 100755
index 0000000..8d5596c
--- /dev/null
+++ b/old_tests/regex/proxy_test.py
@@ -0,0 +1,112 @@
+#!/usr/bin/python
+import unittest
+import re
+import traceback
+
+
+class ProxyRegexTestCase(unittest.TestCase):
+    def testProxy(self):
+        """
+        Run a list of possible proxy= values through the regex and check for
+        correct results.
+
+        tests are in the form of: (proxy string, match.groups() tuple)
+        """
+        tests = [ ( "proxy.host",
+                      (None, None, None, None, 'proxy.host', None, None) ),
+
+                  ( "proxy.host:3128",
+                      (None, None, None, None, 'proxy.host', ':3128', None) ),
+
+                  ( "user:password at proxy.host",
+                      (None, 'user:password@', 'user', ':password', 'proxy.host', None, None) ),
+
+                  ( "user at proxy.host",
+                      (None, 'user@', 'user', None, 'proxy.host', None, None) ),
+
+                  ( "user:password at proxy.host:3128",
+                      (None, 'user:password@', 'user', ':password', 'proxy.host', ':3128', None) ),
+
+                  ( "user at proxy.host:3128",
+                      (None, 'user@', 'user', None, 'proxy.host', ':3128', None) ),
+
+                  ( "proxy.host/blah/blah",
+                      (None, None, None, None, 'proxy.host', None, '/blah/blah') ),
+
+                  ( "proxy.host:3128/blah/blah",
+                      (None, None, None, None, 'proxy.host', ':3128', '/blah/blah') ),
+
+                  ( "user:password at proxy.host/blah/blah",
+                      (None, 'user:password@', 'user', ':password', 'proxy.host', None, '/blah/blah') ),
+
+                  ( "user at proxy.host/blah/blah",
+                      (None, 'user@', 'user', None, 'proxy.host', None, '/blah/blah') ),
+
+                  ( "user:password at proxy.host:3128/blah/blah",
+                      (None, 'user:password@', 'user', ':password', 'proxy.host', ':3128', "/blah/blah") ),
+
+                  ( "user at proxy.host:3128/blah/blah",
+                      (None, 'user@', 'user', None, 'proxy.host', ':3128', "/blah/blah") ),
+
+
+
+                  ( "http://proxy.host",
+                      ('http://', None, None, None, 'proxy.host', None, None) ),
+
+                  ( "http://proxy.host:3128",
+                      ('http://', None, None, None, 'proxy.host', ':3128', None) ),
+
+                  ( "http://user:password@proxy.host",
+                      ('http://', 'user:password@', 'user', ':password', 'proxy.host', None, None) ),
+
+                  ( "http://user@proxy.host",
+                      ('http://', 'user@', 'user', None, 'proxy.host', None, None) ),
+
+                  ( "http://user:password@proxy.host:3128",
+                      ('http://', 'user:password@', 'user', ':password', 'proxy.host', ':3128', None) ),
+
+                  ( "http://user@proxy.host:3128",
+                      ('http://', 'user@', 'user', None, 'proxy.host', ':3128', None) ),
+
+                  ( "http://proxy.host/blah/blah",
+                      ('http://', None, None, None, 'proxy.host', None, '/blah/blah') ),
+
+                  ( "http://proxy.host:3128/blah/blah",
+                      ('http://', None, None, None, 'proxy.host', ':3128', '/blah/blah') ),
+
+                  ( "http://user:password@proxy.host/blah/blah",
+                      ("http://", 'user:password@', 'user', ':password', 'proxy.host', None, '/blah/blah') ),
+
+                  ( "http://user@proxy.host/blah/blah",
+                      ("http://", 'user@', 'user', None, 'proxy.host', None, '/blah/blah') ),
+
+                  ( "http://user:password@proxy.host:3128/blah/blah",
+                      ("http://", 'user:password@', 'user', ':password', 'proxy.host', ':3128', '/blah/blah') ),
+
+                  ( "http://user@proxy.host:3128/blah/blah",
+                      ("http://", 'user@', 'user', None, 'proxy.host', ':3128', '/blah/blah') ),
+
+                ]
+
+
+        # This is from yumupdate.py and needs to be updated when it changes
+        pattern = re.compile("([A-Za-z]+://)?(([A-Za-z0-9]+)(:[^:@]+)?@)?([^:/]+)(:[0-9]+)?(/.*)?")
+
+        got_error = False
+        for proxy, result in tests:
+            try:
+                self.assertEqual(pattern.match(proxy).groups(), result)
+            except AssertionError as error:
+                got_error = True
+                print error
+
+        if got_error:
+            self.fail()
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(ProxyRegexTestCase)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/Makefile.am b/tests/Makefile.am
deleted file mode 100644
index cb4c701..0000000
--- a/tests/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-# tests/Makefile.am for anaconda
-#
-# Copyright (C) 2009  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: David Cantrell <dcantrell at redhat.com>
-
-SUBDIRS = mock kickstart_test regex pyanaconda_test pylint logpicker_test
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/tests/kickstart_test/Makefile.am b/tests/kickstart_test/Makefile.am
deleted file mode 100644
index 20b7a14..0000000
--- a/tests/kickstart_test/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-# tests/kickstart/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Chris Lumens <clumens at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/tests/kickstart_test/commands_test.py b/tests/kickstart_test/commands_test.py
deleted file mode 100644
index feb7132..0000000
--- a/tests/kickstart_test/commands_test.py
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Chris Lumens <clumens at redhat.com>
-import unittest
-import sys
-from mock import Mock, patch, TestCase, acceptance
-
-class O(object):
-    pass
-
-# Verify that each kickstart command in anaconda uses the correct version of
-# that command as provided by pykickstart.  That is, if there's an FC3 and an
-# F10 version of a command, make sure anaconda >= F10 uses the F10 version.
-class CommandVersionTestCase(TestCase):
-    def setUp(self):
-        self.setupModules([
-            'pyanaconda.isys',
-            'pyanaconda.storage',
-            'pyanaconda.storage.isys',
-            'pyanaconda.storage.devices',
-            'pyanaconda.storage.formats',
-            'pyanaconda.storage.partitioning',
-            'pyanaconda.storage.deviceaction',
-            'pyanaconda.storage.devicelibs',
-            'pyanaconda.storage.devicelibs.lvm',
-            'pyanaconda.storage.iscsi',
-            'pyanaconda.storage.fcoe',
-            'pyanaconda.storage.udev',
-            'pyanaconda.storage.zfcp',
-            'iutil',
-            'constants',
-            'flags',
-            'anaconda_log',
-            'parted',
-            'block'])
-
-        import pyanaconda.anaconda_log
-        pyanaconda.anaconda_log.init()
-
-        from pyanaconda import kickstart
-        import pykickstart.version
-
-        self.handler = pykickstart.version.makeVersion(kickstart.ver)
-
-    def tearDown(self):
-        self.tearDownModules()
-
-
-    @acceptance
-    def commands_test(self):
-        for (commandName, commandObj) in kickstart.commandMap.iteritems():
-            baseClass = commandObj().__class__.__bases__[0]
-            pykickstartClass = self.handler.commands[commandName].__class__
-            self.assertEqual(baseClass.__name__, pykickstartClass.__name__)
-
-# Do the same thing as CommandVersionTestCase, but for data objects.
-class DataVersionTestCase(TestCase):
-    def setUp(self):
-        import pyanaconda.anaconda_log
-        pyanaconda.anaconda_log.init()
-
-        from pyanaconda import kickstart
-        import pykickstart.version
-
-        self.handler = pykickstart.version.makeVersion(kickstart.ver)
-
-    @acceptance
-    def data_test(self):
-        for (dataName, dataObj) in kickstart.dataMap.iteritems():
-            baseClass = dataObj().__class__.__bases__[0]
-
-            # pykickstart does not expose data objects a mapping the way it
-            # does command objects.
-            pykickstartClass = eval("self.handler.%s" % dataName)
-
-            self.assertEqual(baseClass.__name__, pykickstartClass.__name__)
-
-
diff --git a/tests/logpicker_test/Makefile.am b/tests/logpicker_test/Makefile.am
deleted file mode 100644
index 0671b2f..0000000
--- a/tests/logpicker_test/Makefile.am
+++ /dev/null
@@ -1,30 +0,0 @@
-# tests/logpicker_test/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Tomas Mlcoch <tmlcoch at redhat.com>
-
-SUBDIRS = archiving_test logmining_test sending_test
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
-
-ANACDIR = $(top_builddir)/pyanaconda
-TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
-
-TESTS = logpicker_test.py \
-    main_test.py
diff --git a/tests/logpicker_test/archiving_test/Makefile.am b/tests/logpicker_test/archiving_test/Makefile.am
deleted file mode 100644
index 481672c..0000000
--- a/tests/logpicker_test/archiving_test/Makefile.am
+++ /dev/null
@@ -1,28 +0,0 @@
-# tests/logpicker_test/archiving_test/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Tomas Mlcoch <tmlcoch at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
-
-ANACDIR = $(top_builddir)/pyanaconda
-TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
-
-TESTS = archivebaseclass_test.py \
-    bzip2archive_test.py
diff --git a/tests/logpicker_test/archiving_test/archivebaseclass_test.py b/tests/logpicker_test/archiving_test/archivebaseclass_test.py
deleted file mode 100644
index 2f4f0e6..0000000
--- a/tests/logpicker_test/archiving_test/archivebaseclass_test.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import mock
-
-class ArchiveBaseClassTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def create_tmp_tar_test(self):
-        import log_picker.archiving as archiving
-               
-        FILE1 = "/tmp/abcd/file1"
-        FILE2 = "/tmp/abcd/file2"
-        FILELIST = [FILE1, FILE2]
-        TMPFILE = "/tmp/tmpfile.tar"
-        
-        archiving.tempfile = mock.Mock()
-        archiving.tempfile.mkstemp.return_value = "", TMPFILE
-        archiving.tarfile = mock.Mock()
-        
-        self.fs.open(FILE1, 'w').write('1\n')
-        self.fs.open(FILE2, 'w').write('2\n')
-        self.fs.open(TMPFILE, 'w')
-        
-        obj = archiving.ArchiveBaseClass()
-        ret = obj._create_tmp_tar(FILELIST)
-        
-        self.assertEqual(TMPFILE, ret)
-        self.assertEqual(archiving.tarfile.open().add.call_args_list, 
-            [((FILE1,), {'arcname': 'abcd/file1'}), 
-             ((FILE2,), {'arcname': 'abcd/file2'})]
-         )
-
diff --git a/tests/logpicker_test/archiving_test/bzip2archive_test.py b/tests/logpicker_test/archiving_test/bzip2archive_test.py
deleted file mode 100644
index aa01e95..0000000
--- a/tests/logpicker_test/archiving_test/bzip2archive_test.py
+++ /dev/null
@@ -1,119 +0,0 @@
-import os
-import mock
-import tempfile
-from log_picker.archiving import ArchivationError
-
-
-class Bzip2ArchiveTest(mock.TestCase):
-    def setUp(self):
-        self.tmp_files = []
-        pass
-    
-    def _get_tmp(self):
-        _, filename = tempfile.mkstemp()
-        self.tmp_files.append(filename)
-        return filename
-    
-    def tearDown(self):
-        for file in self.tmp_files:
-            os.unlink(file)
-    
-    def mimetype_test(self):
-        from log_picker.archiving import Bzip2Archive
-        obj = Bzip2Archive(usetar=True)
-        ret = obj.mimetype
-        self.assertEqual(ret, 'application/x-bzip2')
-    
-    def support_compression_test(self):
-        from log_picker.archiving import Bzip2Archive
-        obj = Bzip2Archive(usetar=True)
-        ret = obj.support_compression
-        self.assertTrue(ret)
-    
-    def file_ext_1_test(self):
-        from log_picker.archiving import Bzip2Archive
-        obj = Bzip2Archive(usetar=True)
-        ret = obj.file_ext
-        self.assertEqual(ret, '.tar.bz2')
-    
-    def file_ext_2_test(self):
-        from log_picker.archiving import Bzip2Archive
-        obj = Bzip2Archive(usetar=False)
-        ret = obj.file_ext
-        self.assertEqual(ret, '.bz2')
-    
-    def create_archive_1_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        infile1 = self._get_tmp()
-        infile2 = self._get_tmp()
-        
-        obj = Bzip2Archive(usetar=False)
-        self.assertRaises(ArchivationError, obj.create_archive, out_filename, \
-                            [infile1, infile2])
-        
-    def create_archive_2_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        
-        obj = Bzip2Archive(usetar=False)
-        self.assertRaises(ArchivationError, obj.create_archive, out_filename, [])
-
-    def create_archive_3_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        
-        obj = Bzip2Archive(usetar=True)
-        self.assertRaises(ArchivationError, obj.create_archive, out_filename, [])
-    
-    def create_archive_4_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        infile1 = self._get_tmp()
-        infile2 = self._get_tmp()
-        
-        obj = Bzip2Archive(usetar=True)
-        # Because both files (infile1 and infile2) are empty
-        self.assertRaises(ArchivationError, obj.create_archive, out_filename, 
-                            [infile1, infile2])
-
-    def create_archive_5_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        infile1 = self._get_tmp()
-        infile2 = self._get_tmp()
-        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
-        open(infile2, 'w').write('1234567890')
-        
-        obj = Bzip2Archive(usetar=True)
-        obj.create_archive(out_filename, [infile1, infile2])
-        self.assertTrue(os.path.getsize(out_filename))
-    
-    def create_archive_6_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        infile1 = self._get_tmp()
-        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
-        
-        obj = Bzip2Archive(usetar=False)
-        obj.create_archive(out_filename, [infile1])
-        self.assertTrue(os.path.getsize(out_filename))
-    
-    def create_archive_7_test(self):
-        from log_picker.archiving import Bzip2Archive
-        
-        out_filename = self._get_tmp()
-        infile1 = self._get_tmp()
-        open(infile1, 'w').write('abcdefghijklmnopqrstuvwxyz')
-        
-        obj = Bzip2Archive(usetar=True)
-        obj.create_archive(out_filename, [infile1])
-        self.assertTrue(os.path.getsize(out_filename))
-        
-    
diff --git a/tests/logpicker_test/logmining_test/Makefile.am b/tests/logpicker_test/logmining_test/Makefile.am
deleted file mode 100644
index 4c6dfaa..0000000
--- a/tests/logpicker_test/logmining_test/Makefile.am
+++ /dev/null
@@ -1,31 +0,0 @@
-# tests/logpicker_test/logmining_test/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Tomas Mlcoch <tmlcoch at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
-
-ANACDIR = $(top_builddir)/pyanaconda
-TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
-
-TESTS = anacondalogminer_test.py \
-    dmsetupinfologminer_test.py \
-    dmsetuplslogminer_test.py \
-    filesystemlogminer_test.py \
-    logminerbaseclass_test.py
diff --git a/tests/logpicker_test/logmining_test/anacondalogminer_test.py b/tests/logpicker_test/logmining_test/anacondalogminer_test.py
deleted file mode 100644
index 22cd1c3..0000000
--- a/tests/logpicker_test/logmining_test/anacondalogminer_test.py
+++ /dev/null
@@ -1,125 +0,0 @@
-import mock
-
-class AnacondaLogMinerTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def action_test(self):
-        import log_picker.logmining as logmining
-        
-        ANACONDA_LOG = "anaconda-tb-log"
-        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
-        LOG_CONTENT = "Test content\n"
-        
-        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
-        
-        logmining.os = mock.Mock()
-        listdir_values = [[ANACONDA_LOG], []]
-        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
-        
-        logmining.open = self.fs.open
-        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
-        
-        proc_mock = mock.Mock()
-        proc_mock.returncode = 0
-        logmining.subprocess = mock.Mock()
-        logmining.subprocess.Popen.return_value = proc_mock
-        
-        logmining.time = mock.Mock()
-        
-        OUTFILE = '/tmp/outfile'
-        f = self.fs.open(OUTFILE, 'w')
-        
-        obj = logmining.AnacondaLogMiner(f)
-        obj._action()
-        f.close()
-        
-        self.assertEqual(self.fs[OUTFILE],
-                            "%s:\n%s\n" % (ANACONDA_LOG_PATH, LOG_CONTENT))
-    
-    def action_raise_1_test(self):
-        import log_picker.logmining as logmining
-        
-        logmining.os = mock.Mock()
-        listdir_values = [[]]
-        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
-        
-        logmining.open = self.fs.open
-        
-        obj = logmining.AnacondaLogMiner()
-        self.assertRaises(logmining.LogMinerError, obj._action)
-    
-    def action_raise_2_test(self):
-        import log_picker.logmining as logmining
-              
-        logmining.os = mock.Mock()
-        listdir_values = [[]]
-        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
-        
-        logmining.open = self.fs.open
-        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
-        
-        proc_mock = mock.Mock()
-        proc_mock.returncode = 1
-        logmining.subprocess = mock.Mock()
-        logmining.subprocess.Popen.return_value = proc_mock
-                
-        obj = logmining.AnacondaLogMiner()
-        self.assertRaises(logmining.LogMinerError, obj._action)
-    
-    def action_raise_3_test(self):
-        import log_picker.logmining as logmining
-        
-        ANACONDA_LOG = "anaconda-tb-log"
-        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
-        LOG_CONTENT = "Test content\n"
-        
-        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
-        
-        logmining.os = mock.Mock()
-        listdir_values = [[], []]
-        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
-        
-        logmining.open = self.fs.open
-        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
-        
-        proc_mock = mock.Mock()
-        proc_mock.returncode = 0
-        logmining.subprocess = mock.Mock()
-        logmining.subprocess.Popen.return_value = proc_mock
-        
-        logmining.time = mock.Mock()
-        
-        obj = logmining.AnacondaLogMiner()
-        self.assertRaises(logmining.LogMinerError, obj._action)
-
-    def action_raise_4_test(self):
-        import log_picker.logmining as logmining
-        
-        ANACONDA_LOG = "different-log"
-        ANACONDA_LOG_PATH = "/tmp/%s" % ANACONDA_LOG
-        LOG_CONTENT = "Test content\n"
-        
-        self.fs.open(ANACONDA_LOG_PATH, 'w').write(LOG_CONTENT)
-        
-        logmining.os = mock.Mock()
-        listdir_values = [[ANACONDA_LOG], []]
-        logmining.os.listdir.side_effect = lambda x: listdir_values.pop()
-        
-        logmining.open = self.fs.open
-        self.fs.open('/var/run/anaconda.pid', 'w').write('555\n')
-        
-        proc_mock = mock.Mock()
-        proc_mock.returncode = 0
-        logmining.subprocess = mock.Mock()
-        logmining.subprocess.Popen.return_value = proc_mock
-        
-        logmining.time = mock.Mock()
-               
-        obj = logmining.AnacondaLogMiner()
-        self.assertRaises(logmining.LogMinerError, obj._action)
-        
diff --git a/tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py b/tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
deleted file mode 100644
index 9aa3c81..0000000
--- a/tests/logpicker_test/logmining_test/dmsetupinfologminer_test.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import mock
-
-class DmSetupInfoLogMinerTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def action_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.DmSetupInfoLogMiner()
-        obj._run_command = mock.Mock()
-        obj._action()
-        
-        self.assertTrue(obj._run_command.called)
-
diff --git a/tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py b/tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
deleted file mode 100644
index c0d4bc4..0000000
--- a/tests/logpicker_test/logmining_test/dmsetuplslogminer_test.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import mock
-
-class DmSetupLsLogMinerTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def action_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.DmSetupLsLogMiner()
-        obj._run_command = mock.Mock()
-        obj._action()
-        
-        self.assertTrue(obj._run_command.called)
-
diff --git a/tests/logpicker_test/logmining_test/filesystemlogminer_test.py b/tests/logpicker_test/logmining_test/filesystemlogminer_test.py
deleted file mode 100644
index a9d9836..0000000
--- a/tests/logpicker_test/logmining_test/filesystemlogminer_test.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import mock
-
-class FileSystemLogMinerTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def size_conversion_1_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(24)
-        self.assertEqual(size, 24)
-        self.assertEqual(unit, "")
-    
-    def size_conversion_2_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(2400)
-        self.assertEqual(size, 2.3)
-        self.assertEqual(unit, "K")
-    
-    def size_conversion_3_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(1024)
-        self.assertEqual(size, 1)
-        self.assertEqual(unit, "K")
-    
-    def size_conversion_4_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(1048576)
-        self.assertEqual(size, 1)
-        self.assertEqual(unit, "M")
-    
-    def size_conversion_5_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(1160576)
-        self.assertEqual(size, 1.1)
-        self.assertEqual(unit, "M")
-    
-    def size_conversion_6_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(1073741824)
-        self.assertEqual(size, 1)
-        self.assertEqual(unit, "G")
-    
-    def size_conversion_7_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(1273741824)
-        self.assertEqual(size, 1.2)
-        self.assertEqual(unit, "G")
-    
-    def size_conversion_8_test(self):
-        import log_picker.logmining as logmining
-        
-        obj = logmining.FileSystemLogMiner()
-        size, unit = obj._size_conversion(0)
-        self.assertEqual(size, 0)
-        self.assertEqual(unit, "")
-
diff --git a/tests/logpicker_test/logmining_test/logminerbaseclass_test.py b/tests/logpicker_test/logmining_test/logminerbaseclass_test.py
deleted file mode 100644
index aad9af8..0000000
--- a/tests/logpicker_test/logmining_test/logminerbaseclass_test.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import mock
-
-class LogminingBaseClassTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def get_filename_test(self):
-        from log_picker.logmining import LogMinerBaseClass
-        
-        ret = LogMinerBaseClass.get_filename()
-        self.assertEqual(ret, LogMinerBaseClass._filename)
-    
-    def get_description_test(self):
-        from log_picker.logmining import LogMinerBaseClass
-        
-        ret = LogMinerBaseClass.get_description()
-        self.assertEqual(ret, LogMinerBaseClass._description)
-    
-    def set_logfile_test(self):
-        from log_picker.logmining import LogMinerBaseClass
-        
-        FILENAME = "file123"
-        
-        obj = LogMinerBaseClass()
-        obj.set_logfile(FILENAME)
-        self.assertEqual(FILENAME, obj.logfile)
-       
-    def write_separator_test(self):
-        import log_picker.logmining as logmining
-        logmining.open = self.fs.open
-        
-        OUTFILE = '/tmp/logfile'
-        f = self.fs.open(OUTFILE, 'w')
-        
-        obj = logmining.LogMinerBaseClass(f)
-        obj._write_separator()
-        f.close()
-        
-        self.assertEqual(self.fs[OUTFILE], '\n\n')
-    
-    def write_files_1_test(self):
-        import log_picker.logmining as logmining
-        logmining.open = self.fs.open
-        
-        FILE = '/tmp/infile'
-        CONTENT = "some_random_456_content\n"
-        self.fs.open(FILE, 'w').write(CONTENT)
-        
-        OUTFILE = '/tmp/logfile'
-        f = self.fs.open(OUTFILE, 'w')
-        
-        obj = logmining.LogMinerBaseClass(f)
-        obj._write_files(FILE)
-        f.close()
-               
-        self.assertEqual('%s:\n%s\n' % (FILE, CONTENT), self.fs[OUTFILE])
-        
-    def write_files_2_test(self):
-        import log_picker.logmining as logmining
-        logmining.open = self.fs.open
-        
-        FILE_1 = '/tmp/infile1'
-        FILE_2 = '/tmp/infile2'
-        CONTENT_1 = "some_random_456_content\n"
-        CONTENT_2 = "next_line_789\n"
-        self.fs.open(FILE_1, 'w').write(CONTENT_1)
-        self.fs.open(FILE_2, 'w').write(CONTENT_2)
-        
-        OUTFILE = '/tmp/logfile'
-        f = self.fs.open(OUTFILE, 'w')
-        
-        obj = logmining.LogMinerBaseClass(f)
-        obj._write_files([FILE_1, FILE_2])
-        f.close()
-               
-        self.assertEqual('%s:\n%s\n%s:\n%s\n' % \
-                (FILE_1, CONTENT_1, FILE_2, CONTENT_2), self.fs[OUTFILE])
-    
-    def run_command_test(self):
-        import log_picker.logmining as logmining
-               
-        COMMAND = "some_command param1 param2"
-        STDOUT = "some output"
-        STDERR = "some error"
-        RETCODE = 1
-        
-        proc_mock = mock.Mock()
-        proc_mock.returncode = RETCODE
-        proc_mock.communicate.return_value = (STDOUT, STDERR)
-        logmining.subprocess = mock.Mock()
-        logmining.subprocess.Popen.return_value = proc_mock
-        
-        OUTFILE = "/tmp/outfile"
-        f = self.fs.open(OUTFILE, 'w')
-        
-        obj = logmining.LogMinerBaseClass(f)
-        obj._run_command(COMMAND)
-        f.close()
-        
-        self.assertEqual(self.fs[OUTFILE],
-                "STDOUT:\nsome output\nSTDERR:\nsome error\nRETURN CODE: 1\n")
-
diff --git a/tests/logpicker_test/logpicker_test.py b/tests/logpicker_test/logpicker_test.py
deleted file mode 100644
index a62d63d..0000000
--- a/tests/logpicker_test/logpicker_test.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import os
-import sys
-import mock
-
-
-class LogPickerTest(mock.TestCase):
-    def setUp(self):
-        pass
-
-    def getlogs_1_test(self):
-        from log_picker import LogPicker
-
-        miner = mock.Mock()
-        
-        obj = LogPicker(miners=[miner], use_one_file=True)
-        obj.getlogs()
-        
-        self.assertTrue(miner.set_logfile.called)
-        self.assertTrue(miner.getlog.called)
-    
-    def getlogs_2_test(self):
-        from log_picker import LogPicker
-        from log_picker.logmining import LogMinerError
-        
-        miner = mock.Mock()
-        miner.getlog.side_effect = LogMinerError('Just a test')
-        
-        obj = LogPicker(miners=[miner], use_one_file=True)
-        # Temporary redirect stderr output
-        sys.stderr, backup = mock.Mock(), sys.stderr
-        obj.getlogs()
-        sys.stderr = backup
-        
-        self.assertTrue(True)
-        
-    def send_1_test(self):
-        from log_picker import LogPicker
-        
-        sender = mock.Mock()
-        
-        obj = LogPicker(sender_obj=sender)
-        obj.files = ["file"]
-        obj.send()
-        
-        self.assertTrue(sender.sendfile.called)
-        self.assertEqual(sender.sendfile.call_args, 
-                                        (('file', 'text/plain'), {}))
-
-    def send_2_test(self):
-        from log_picker import LogPicker
-        
-        sender = mock.Mock()
-        archiver = mock.Mock()
-        archiver.mimetype = "application/anything"
-        
-        obj = LogPicker(sender_obj=sender, archive_obj=archiver)
-        obj.files = ["file"]
-        obj.archive = "file2"
-        obj.send()
-        
-        self.assertTrue(sender.sendfile.called)
-        self.assertEqual(sender.sendfile.call_args, 
-                                        (('file2', 'application/anything'), {}))
-
-    def create_archive_1_test(self):
-        from log_picker import LogPicker
-        
-        archiver = mock.Mock()
-        archiver.file_ext = ".zip"
-                
-        obj = LogPicker(archive_obj=archiver)
-        obj.create_archive()
-        
-        self.assertTrue(archiver.create_archive.called)
-    
-    def get_tmp_file_test(self):
-        from log_picker import LogPicker
-        
-        obj = LogPicker()
-        ret = obj._get_tmp_file("name")
-        self.assertTrue(os.path.isfile(ret))
-    
-    def errprint_test(self):
-        from log_picker import LogPicker
-        
-        obj = LogPicker()
-        # Temporary redirect stderr output
-        sys.stderr, backup = mock.Mock(), sys.stderr
-        obj._errprint("message")
-        res, sys.stderr = sys.stderr, backup
-        self.assertTrue(res.write.called)
-        self.assertEqual(res.write.call_args[0][0], 'message\n')
-        
diff --git a/tests/logpicker_test/main_test.py b/tests/logpicker_test/main_test.py
deleted file mode 100644
index 0c53dde..0000000
--- a/tests/logpicker_test/main_test.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#import mock
-
-#
-# Cannot be used, because main file "logpicker" doesn't have ".py" 
-# extension ( => logpicker cannot be imported)
-#
-
-
-#class LogPickerMainTest(mock.TestCase):
-#    def setUp(self):
-#        pass
-#    
-#    def injector_injectarchivator_test(self):
-#        import logpicker
-#        import log_picker.archiving as archiving
-#        
-#        ret = logpicker.Injector.injectArchivator(mock.Mock())
-#        self.assertEqual(ret, archiving.Bzip2Archive)
-
diff --git a/tests/logpicker_test/sending_test/Makefile.am b/tests/logpicker_test/sending_test/Makefile.am
deleted file mode 100644
index 6c944a6..0000000
--- a/tests/logpicker_test/sending_test/Makefile.am
+++ /dev/null
@@ -1,33 +0,0 @@
-# tests/logpicker_test/sending_test/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Tomas Mlcoch <tmlcoch at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
-
-ANACDIR = $(top_builddir)/pyanaconda
-TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir):$(top_builddir)/utils
-
-TESTS = bugzillasender_test.py \
-    emailsender_test.py \
-    ftpsender_test.py \
-    localsender_test.py \
-    scpsender_test.py \
-    senderbaseclass_test.py \
-    stratasender_test.py
diff --git a/tests/logpicker_test/sending_test/bugzillasender_test.py b/tests/logpicker_test/sending_test/bugzillasender_test.py
deleted file mode 100644
index 03b07f3..0000000
--- a/tests/logpicker_test/sending_test/bugzillasender_test.py
+++ /dev/null
@@ -1,99 +0,0 @@
-import mock
-
-class BugzillaBaseClassTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(['report.plugins.bugzilla', 
-                            'report.plugins.bugzilla.filer'])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def connect_and_login_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        bugzillasender.filer = mock.Mock()
-        
-        USERNAME = "user"
-        PASSWORD = "foopassword"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        obj.connect_and_login(USERNAME, PASSWORD)
-        
-        self.assertTrue(bugzillasender.filer.BugzillaFiler().login.called)
-        self.assertEqual(bugzillasender.filer.BugzillaFiler().login.call_args,
-                            (('user', 'foopassword'), {}))
-    
-    def connect_and_login_fail_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        bugzillasender.filer = mock.Mock()
-        bugzillasender.filer.BugzillaFiler().login.side_effect = \
-                                        bugzillasender.LoginError('foo', 'bar')
-        
-        USERNAME = "user"
-        PASSWORD = "foopassword"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        self.assertRaises(bugzillasender.SenderError, obj.connect_and_login, \
-                                                            USERNAME, PASSWORD)
-        self.assertTrue(bugzillasender.filer.BugzillaFiler().login.called)
-        self.assertEqual(bugzillasender.filer.BugzillaFiler().login.call_args,
-                            (('user', 'foopassword'), {}))
-    
-    def set_bug_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        BUGID = "123456789"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        obj.set_bug(BUGID)
-        
-        self.assertEqual(BUGID, obj.bug_id)
-    
-    def set_comment_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        COMMENT = "some comment"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        obj.set_comment(COMMENT)
-        
-        self.assertEqual(COMMENT, obj.comment)
-    
-    def sendfile_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        bugzillasender.os = mock.Mock()
-        bugzillasender.os.path = mock.Mock()
-        bugzillasender.os.path.basename = lambda x: x
-        
-        FILE = "/tmp/somefile"
-        MIMETYPE = "text/plain"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        obj._get_description = mock.Mock()
-        obj.bzfiler = mock.Mock()
-        obj.sendfile(FILE, MIMETYPE)
-        
-        self.assertTrue(obj._get_description.called)
-        self.assertTrue(obj.bzfiler.getbug.called)
-        self.assertTrue(obj.bzfiler.getbug().attachfile.called)
-    
-    def sendfile_raise_test(self):
-        import log_picker.sending.bugzillasender as bugzillasender
-        
-        bugzillasender.os = mock.Mock()
-        bugzillasender.os.path = mock.Mock()
-        bugzillasender.os.path.basename = lambda x: x
-        
-        FILE = "/tmp/somefile"
-        MIMETYPE = "text/plain"
-        
-        obj = bugzillasender.BugzillaBaseClass()
-        obj._get_description = mock.Mock()
-        obj.bzfiler = mock.Mock()
-        obj.bzfiler.getbug.side_effect = ValueError('Test exception')
-        
-        self.assertRaises(bugzillasender.SenderError, obj.sendfile, FILE, MIMETYPE)
-
diff --git a/tests/logpicker_test/sending_test/emailsender_test.py b/tests/logpicker_test/sending_test/emailsender_test.py
deleted file mode 100644
index 504138a..0000000
--- a/tests/logpicker_test/sending_test/emailsender_test.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import mock
-
-class EmailSenderTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-
-    def set_comment_test(self):
-        import log_picker.sending.emailsender as email_s
-        
-        COMMENT = "test comment"
-        
-        obj = email_s.EmailSender("", "", "", "")
-        obj.set_comment(COMMENT)
-        
-        self.assertEqual(COMMENT, obj.comment)
-    
-    def sendfile_test(self):
-        import log_picker.sending.emailsender as email_s
-        
-        FILE = "/tmp/some_file"
-        MIMETYPE = "text/plain"
-        
-        email_s.smtplib = mock.Mock()
-        email_s.open = self.fs.open
-        self.fs.open(FILE, 'w').write('some file content\n')
-               
-        class Fake_MIMEMultipart(mock.Mock):
-            def __getitem__(self, key):
-                return self.__dict__[key]
-            
-            def __setitem__(self, key, value):
-                self.__dict__[key] = value
-        
-        email_s.email = mock.Mock()
-        email_s.email.mime.multipart.MIMEMultipart.return_value = \
-                                                            Fake_MIMEMultipart()
-               
-        obj = email_s.EmailSender("", "", "", "")
-        obj.sendfile(FILE, MIMETYPE)
-        
-        self.assertTrue(email_s.smtplib.SMTP().sendmail.called)
-        self.assertTrue(email_s.smtplib.SMTP().quit.called)
-        self.assertEqual(2,
-            len(email_s.email.mime.base.MIMEBase().set_payload.call_args_list))
-    
-    def sendfile_fail_1_test(self):
-        import log_picker.sending.emailsender as email_s
-        
-        FILE = "/tmp/some_file"
-        MIMETYPE = "text/plain"
-        
-        email_s.smtplib = mock.Mock()
-        import socket
-        email_s.smtplib.socket.gaierror = socket.gaierror
-        email_s.smtplib.SMTP.side_effect = email_s.smtplib.socket.gaierror()
-        email_s.open = self.fs.open
-        self.fs.open(FILE, 'w').write('some file content\n')
-               
-        class Fake_MIMEMultipart(mock.Mock):
-            def __getitem__(self, key):
-                return self.__dict__[key]
-            
-            def __setitem__(self, key, value):
-                self.__dict__[key] = value
-        
-        email_s.email = mock.Mock()
-        email_s.email.mime.multipart.MIMEMultipart.return_value = \
-                                                        Fake_MIMEMultipart()
-               
-        obj = email_s.EmailSender("", "", "", "")
-        self.assertRaises(email_s.SenderError, obj.sendfile, FILE, MIMETYPE)
-
-    def sendfile_fail_2_test(self):
-        import log_picker.sending.emailsender as email_s
-        
-        FILE = "/tmp/some_file"
-        MIMETYPE = "text/plain"
-        
-        email_s.smtplib = mock.Mock()
-        import smtplib
-        email_s.smtplib.SMTPRecipientsRefused = smtplib.SMTPRecipientsRefused
-        email_s.smtplib.SMTP().sendmail.side_effect = \
-                                            smtplib.SMTPRecipientsRefused("")
-        email_s.open = self.fs.open
-        self.fs.open(FILE, 'w').write('some file content\n')
-               
-        class Fake_MIMEMultipart(mock.Mock):
-            def __getitem__(self, key):
-                return self.__dict__[key]
-            
-            def __setitem__(self, key, value):
-                self.__dict__[key] = value
-        
-        email_s.email = mock.Mock()
-        email_s.email.mime.multipart.MIMEMultipart.return_value = \
-                                                        Fake_MIMEMultipart()
-               
-        obj = email_s.EmailSender("", "", "", "")
-        self.assertRaises(email_s.SenderError, obj.sendfile, FILE, MIMETYPE)
-    
diff --git a/tests/logpicker_test/sending_test/ftpsender_test.py b/tests/logpicker_test/sending_test/ftpsender_test.py
deleted file mode 100644
index 0bbc1e4..0000000
--- a/tests/logpicker_test/sending_test/ftpsender_test.py
+++ /dev/null
@@ -1,156 +0,0 @@
-import mock
-
-class FtpSenderTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def set_host_1_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        HOST = "foobar"
-        
-        obj = ftp_s.FtpSender()
-        obj.set_host(HOST)
-        
-        self.assertEqual("ftp://%s" % HOST, obj.host)
-    
-    def set_host_2_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        HOST = "ftp://foobar"
-        
-        obj = ftp_s.FtpSender()
-        obj.set_host(HOST)
-        
-        self.assertEqual(HOST, obj.host)
-    
-    def set_login_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        LOGIN = "spiderman"
-        PASSWORD = "jarfly"
-        
-        obj = ftp_s.FtpSender()
-        obj.set_login(LOGIN, PASSWORD)
-        
-        self.assertEqual(LOGIN, obj.username)
-        self.assertEqual(PASSWORD, obj.password)
-
-    def sendfile_1_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        ftp_s.open = self.fs.open
-        ftp_s.ftplib = mock.Mock()
-        ftp_s.os = mock.Mock()
-        ftp_s.os.path.basename = lambda x: x
-        ftp_s.file = lambda x: x
-        
-        HOST = "localhost"
-        FILE = "/tmp/somefile"
-        MIMETYPE = "application/x-bzip2"
-        
-        self.fs.open(FILE, 'w').write("some content")
-        
-        obj = ftp_s.FtpSender()
-        obj.set_host(HOST)
-        obj.sendfile(FILE, MIMETYPE)
-        
-        method_calls = ftp_s.ftplib.FTP().method_calls
-        method_names = [x[0] for x in ftp_s.ftplib.FTP().method_calls] 
-        
-        # Check calls order
-        self.assertEqual(method_names, 
-                ['connect', 'login', 'cwd', 'set_pasv', 'storbinary', 'quit'])
-        
-        # Check arguments
-        PARAMS = 1
-        
-        CONNECT = 0
-        LOGIN = 1
-        CWD = 2
-        SET_PASV = 3
-        STORBINARY = 4
-        QUIT = 5
-        
-        self.assertEqual(method_calls[CONNECT][PARAMS], (HOST, 21))
-        self.assertEqual(method_calls[LOGIN][PARAMS], ())
-        self.assertEqual(method_calls[CWD][PARAMS], ('',))
-        self.assertEqual(method_calls[SET_PASV][PARAMS], (True,))
-        self.assertEqual(method_calls[STORBINARY][PARAMS], 
-                                                    ('STOR %s' % FILE, FILE))
-                                                            
-    def sendfile_2_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        ftp_s.open = self.fs.open
-        ftp_s.ftplib = mock.Mock()
-        ftp_s.os = mock.Mock()
-        ftp_s.os.path.basename = lambda x: x
-        ftp_s.file = lambda x: x
-        
-        PORT = "55"
-        HOST = "localhost"
-        ADDRESS = "%s:%s" % (HOST, PORT)
-        USERNAME = "foo"
-        PASSWORD = "bar"
-        FILE = "/tmp/somefile"
-        MIMETYPE = "application/x-bzip2"
-        
-        self.fs.open(FILE, 'w').write("some content")
-        
-        obj = ftp_s.FtpSender()
-        obj.set_host(ADDRESS)
-        obj.set_login(USERNAME, PASSWORD)
-        obj.sendfile(FILE, MIMETYPE)
-        
-        method_calls = ftp_s.ftplib.FTP().method_calls
-        method_names = [x[0] for x in ftp_s.ftplib.FTP().method_calls] 
-        
-        # Check calls order
-        self.assertEqual(method_names, 
-                ['connect', 'login', 'cwd', 'set_pasv', 'storbinary', 'quit'])
-        
-        # Check arguments
-        PARAMS = 1
-        
-        CONNECT = 0
-        LOGIN = 1
-        CWD = 2
-        SET_PASV = 3
-        STORBINARY = 4
-        QUIT = 5
-        
-        self.assertEqual(method_calls[CONNECT][PARAMS], (HOST, PORT))
-        self.assertEqual(method_calls[LOGIN][PARAMS], (USERNAME, PASSWORD))
-        self.assertEqual(method_calls[CWD][PARAMS], ('',))
-        self.assertEqual(method_calls[SET_PASV][PARAMS], (True,))
-        self.assertEqual(method_calls[STORBINARY][PARAMS], 
-                                                    ('STOR %s' % FILE, FILE))
-    
-    def sendfile_fail_test(self):
-        import log_picker.sending.ftpsender as ftp_s
-        
-        ftp_s.open = self.fs.open
-        ftp_s.ftplib = mock.Mock()
-        ftp_s.os = mock.Mock()
-        ftp_s.file = mock.Mock()
-        import ftplib
-        ftp_s.ftplib = mock.Mock()
-        ftp_s.ftplib.all_errors = ftplib.all_errors
-        ftp_s.ftplib.FTP().storbinary.side_effect = ftplib.error_temp("some")
-        
-        HOST = "localhost"
-        FILE = "/tmp/somefile"
-        MIMETYPE = "application/x-bzip2"
-        
-        self.fs.open(FILE, 'w').write("some content")
-        
-        obj = ftp_s.FtpSender()
-        obj.set_host(HOST)
-        self.assertRaises(ftp_s.SenderError, obj.sendfile, FILE, MIMETYPE)
-        
-        
diff --git a/tests/logpicker_test/sending_test/localsender_test.py b/tests/logpicker_test/sending_test/localsender_test.py
deleted file mode 100644
index cc9d888..0000000
--- a/tests/logpicker_test/sending_test/localsender_test.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import os
-import shutil
-import mock
-
-class ScpSenderTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def set_path_test(self):
-        import log_picker.sending.localsender as local_s
-        
-        PATH = "/tmp/somewhere"
-        
-        obj = local_s.LocalSender()
-        obj.set_path(PATH)
-        
-        self.assertEqual(PATH, obj.path)
-    
-    def sendfile(self):
-        import log_picker.sending.localsender as local_s
-        
-        PATH = "/tmp/a_logfile_xa54hfd4j/"
-        FILE = "testfile"
-        
-        if os.path.exists(PATH):
-            if os.path.isdir(PATH):
-                shutil.rmtree(PATH)
-            else:
-                self.assertTrue(False, "Cannot create test directory: %s" % PATH)
-        
-        os.mkdir(PATH)
-        
-        obj = local_s.LocalSender()
-        obj.set_path(PATH)
-        obj.sendfile(FILE, "")
-        
-        files = len(os.listdir(PATH))
-        
-        shutil.rmtree(PATH)
-        
-        self.assertTrue(files)
-
diff --git a/tests/logpicker_test/sending_test/scpsender_test.py b/tests/logpicker_test/sending_test/scpsender_test.py
deleted file mode 100644
index 41c3ace..0000000
--- a/tests/logpicker_test/sending_test/scpsender_test.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import mock
-
-class ScpSenderTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def set_host_1_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        HOST = "localhost"
-        
-        obj = scp_s.ScpSender()
-        obj.set_host(HOST)
-        
-        self.assertEqual(HOST, obj.host)
-    
-    def set_host_2_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        HOST = "localhost"
-        PORT = 12345
-        ADDRESS = "%s:%s" % (HOST, PORT)
-        
-        obj = scp_s.ScpSender()
-        obj.set_host(ADDRESS)
-        
-        self.assertEqual(HOST, obj.host)
-        self.assertEqual(PORT, obj.port)
-    
-    def set_host_3_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        HOST = "localhost"
-        PORT = "abc"
-        ADDRESS = "%s:%s" % (HOST, PORT)
-        
-        obj = scp_s.ScpSender()
-        obj.set_host(ADDRESS)
-        
-        self.assertEqual(HOST, obj.host)
-        self.assertEqual(None, obj.port)
-    
-    def set_login_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        USERNAME = "foo"
-        
-        obj = scp_s.ScpSender()
-        obj.set_login(USERNAME)
-        
-        self.assertEqual(USERNAME, obj.username)
-    
-    def set_path_1_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        PATH = "/tmp/something"
-        
-        obj = scp_s.ScpSender()
-        obj.set_path(PATH)
-        
-        self.assertEqual(PATH, obj.path)
-
-    def set_path_2_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        obj = scp_s.ScpSender()
-        obj.set_path(None)
-        
-        self.assertEqual(".", obj.path)
-    
-    def sendfile_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        FILE = "/tmp/file"
-        MIMETYPE = "text/plain"
-        USERNAME = "foo"
-        HOST = "localhost"
-        PATH = "/home/foo"
-        
-        scp_s.subprocess = mock.Mock()
-        scp_s.subprocess.Popen().returncode = False
-                
-        obj = scp_s.ScpSender()
-        obj.set_host(HOST)
-        obj.set_login(USERNAME)
-        obj.set_path(PATH)
-        obj.sendfile(FILE, MIMETYPE)
-        
-        TARGET = "%s@%s:%s" % (USERNAME, HOST, PATH)
-        self.assertTrue(TARGET in scp_s.subprocess.Popen.call_args[0][0])
-    
-    def sendfile_fail_1_test(self):
-        import log_picker.sending.scpsender as scp_s
-        
-        FILE = "/tmp/file"
-        MIMETYPE = "text/plain"
-        
-        scp_s.subprocess = mock.Mock()
-        
-        obj = scp_s.ScpSender()
-        self.assertRaises(scp_s.SenderError, obj.sendfile, FILE, MIMETYPE)
-
diff --git a/tests/logpicker_test/sending_test/senderbaseclass_test.py b/tests/logpicker_test/sending_test/senderbaseclass_test.py
deleted file mode 100644
index 8540ee5..0000000
--- a/tests/logpicker_test/sending_test/senderbaseclass_test.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import mock
-
-class SenderBaseClassTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules([])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def get_description_1_test(self):
-        import log_picker.sending.senderbaseclass as senderbaseclass
-        
-        HOSTNAME = "tiger"
-        DATE = "2010-10-10"
-        
-        senderbaseclass.gethostname = mock.Mock(return_value = HOSTNAME)
-        
-        senderbaseclass.datetime = mock.Mock()
-        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
-        
-        obj = senderbaseclass.SenderBaseClass()
-        ret = obj._get_description()
-        self.assertEqual(ret, "%s (%s) %s" % ("", HOSTNAME, DATE))
-    
-    def get_description_2_test(self):
-        import log_picker.sending.senderbaseclass as senderbaseclass
-        
-        PREFIX = "description"
-        HOSTNAME = "lion"
-        DATE = "2011-11-11"
-        
-        senderbaseclass.gethostname = mock.Mock(return_value = HOSTNAME)
-        
-        senderbaseclass.datetime = mock.Mock()
-        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
-        
-        obj = senderbaseclass.SenderBaseClass()
-        ret = obj._get_description(PREFIX)
-        self.assertEqual(ret, "%s (%s) %s" % (PREFIX, HOSTNAME, DATE))
-
-    def get_description_3_test(self):
-        import log_picker.sending.senderbaseclass as senderbaseclass
-        
-        PREFIX = "description"
-        DATE = "2012-12-12"
-        
-        senderbaseclass.gethostname = mock.Mock(side_effect=Exception)
-        
-        senderbaseclass.datetime = mock.Mock()
-        senderbaseclass.datetime.datetime.now().strftime.return_value = DATE
-        
-        obj = senderbaseclass.SenderBaseClass()
-        ret = obj._get_description(PREFIX)
-        self.assertEqual(ret, "%s (%s) %s" % (PREFIX, "", DATE))
-
diff --git a/tests/logpicker_test/sending_test/stratasender_test.py b/tests/logpicker_test/sending_test/stratasender_test.py
deleted file mode 100644
index fcb94b7..0000000
--- a/tests/logpicker_test/sending_test/stratasender_test.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import mock
-
-class StrataSenderTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(['report.plugins.strata'])
-        self.fs = mock.DiskIO()
-    
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def set_login_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        LOGIN = "foo"
-        PASSWORD = "bar"
-        
-        obj = stratasender.StrataSender()
-        obj.set_login(LOGIN, PASSWORD)
-        
-        self.assertEqual(LOGIN, obj.username)
-        self.assertEqual(PASSWORD, obj.password)
-    
-    def set_case_number_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        CASE_NUM = "123"
-        
-        obj = stratasender.StrataSender()
-        obj.set_case_number(CASE_NUM)
-        self.assertEqual(CASE_NUM, obj.case_number)
-    
-    def sendfile_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        FILE = "/tmp/somefile"
-        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <response><title>File Attachment Succeeded</title><body>.</body></response>'''
-        
-        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
-        
-        obj = stratasender.StrataSender()
-        obj.sendfile(FILE, "")
-        
-        self.assertTrue(stratasender.send_report_to_existing_case.called)
-    
-    def sendfile_raise_1_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        FILE = "/tmp/somefile"
-        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <response><title>File Attachment Failed</title><body>401 Unauthorized
-        This request requires authentication....</body></response>'''
-        
-        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
-        
-        obj = stratasender.StrataSender()
-        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
-    
-    def sendfile_raise_2_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        FILE = "/tmp/somefile"
-        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <response><title>File Attachment Failed</title><body>Error : CASE_NOT_FOUND
-        Message: Case 99999999 does not exist</body></response>'''
-        
-        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
-        
-        obj = stratasender.StrataSender()
-        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
-
-    def sendfile_raise_3_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        FILE = "/tmp/somefile"
-        RESPONSE = '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <response><title>File Attachment Failed</title><body>Error : Your
-        computer is under attack of alien intruders (from Mars).</body></response>'''
-        
-        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
-        
-        obj = stratasender.StrataSender()
-        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
-
-    def sendfile_raise_4_test(self):
-        import log_picker.sending.stratasender as stratasender
-        
-        FILE = "/tmp/somefile"
-        RESPONSE = '''This is not XML valid response => something is wrong.'''
-        
-        stratasender.send_report_to_existing_case = mock.Mock(return_value=RESPONSE)
-        
-        obj = stratasender.StrataSender()
-        self.assertRaises(stratasender.SenderError, obj.sendfile, FILE, "")
-
diff --git a/tests/mock/Makefile.am b/tests/mock/Makefile.am
deleted file mode 100644
index 87ebd00..0000000
--- a/tests/mock/Makefile.am
+++ /dev/null
@@ -1,21 +0,0 @@
-# tests/Makefile.am for anaconda
-#
-# Copyright (C) 2009  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: David Cantrell <dcantrell at redhat.com>
-
-EXTRA_DIST = *.py
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/tests/mock/__init__.py b/tests/mock/__init__.py
deleted file mode 100644
index 3fd749a..0000000
--- a/tests/mock/__init__.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# Mocking library for module and code injection, replay tests and other
-# unit testing purposes
-#
-# Copyright (C) 2010
-# Red Hat, Inc.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author(s): Martin Sivak <msivak at redhat.com>
-
-
-from disk import *
-from mock import *
-import unittest
-
-def slow(f):
-    """Decorates a test method as being slow, usefull for python-nose filtering"""
-    f.slow = True
-    return f
-
-def acceptance(f):
-    """Decorates test as belonging to acceptance testing and not useable in common devellopment unit testing. To be used with python-nose filtering."""
-    f.acceptance = True
-    return f
-
-class TestCase(unittest.TestCase):
-    def __init__(self, *args, **kwargs):
-        unittest.TestCase.__init__(self, *args, **kwargs)
-        self.injectedModules = {}
-
-    def setupModules(self, a):
-        """Mock specified list of modules and store the list so it can be
-           properly unloaded during tearDown"""
-
-        import sys
-        self.preexistingModules = set(sys.modules.keys())
-
-        for m in a:
-            sys.modules[m] = Mock()
-            self.injectedModules[m] = sys.modules[m]
-
-    def modifiedModule(self, mname, mod = None):
-        """Mark module (and all it's parents) as tainted"""
-
-        oldname=""
-        for m in mname.split("."):
-            self.injectedModules[oldname+m] = mod
-            oldname += m + "."
-        self.injectedModules[mname] = mod
-
-    def tearDownModules(self):
-        """Unload previously Mocked modules"""
-
-        import sys
-
-        for m in sys.modules.keys():
-            if m in self.preexistingModules and not m in self.injectedModules:
-                continue
-
-            del sys.modules[m]
-
-    def take_over_io(self, disk, target_module):
-        """ Trick target_module into using disk object as the filesystem.
-
-            This is achieved by overriding the module's 'open' binding as well
-            as many global bindings in os.path.
-        """
-        target_module.open = disk.open
-        self.modifiedModule(target_module.__name__)
-
-        import glob
-        self.modifiedModule("glob")
-        glob.glob = disk.glob_glob
-
-        import os
-        self.modifiedModule("os.path")
-        # this is what os.path implementaion points at, reimport:
-        import posixpath
-        self.modifiedModule("posixpath")
-        os.listdir = disk.os_listdir
-        os.path.exists = disk.os_path_exists
-        os.path.isdir = disk.os_path_isdir
-        os.access = disk.os_access
\ No newline at end of file
diff --git a/tests/mock/disk.py b/tests/mock/disk.py
deleted file mode 100644
index 926fe8f..0000000
--- a/tests/mock/disk.py
+++ /dev/null
@@ -1,128 +0,0 @@
-# Copyright (C) 2010
-# Red Hat, Inc.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author(s): Martin Sivak <msivak at redhat.com>
-
-from StringIO import StringIO
-import fnmatch
-import os
-
-class DiskIO(object):
-    """Simple object to simplify mocking of file operations in Mock
-       based testing"""
-
-    class TestFile(StringIO):
-        def __init__(self, store, path, content = ""):
-            StringIO.__init__(self, content)
-            self._store = store
-            self._path = path
-            self._ro = False
-
-        def flush(self):
-            self._store[self._path] = self.getvalue()
-
-        def close(self):
-            self.flush()
-            return StringIO.close(self)
-
-        def __del__(self):
-            try:
-                self.close()
-            except (AttributeError, ValueError):
-                pass
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, *_):
-            self.close()
-
-    class Dir(object):
-        pass
-
-    class Link(object):
-        pass
-
-    def __init__(self):
-        self.reset()
-
-    def __getitem__(self, key):
-        return self.fs[key]
-
-    def __setitem__(self, key, value):
-        self.fs[key] = value
-
-    def reset(self):
-        self.fs = {
-            "/proc": self.Dir,
-            "/proc/cmdline": "linux",
-        }
-        self._pwd = "/"
-
-    #Emulate file objects
-    def open(self, filename, mode = "r"):
-        path = os.path.join(self._pwd, filename)
-        content = self.fs.get(path, None)
-        if content == self.Dir:
-            raise IOError("[Errno 21] Is a directory: '%s'" % (path))
-        elif mode.startswith("w"):
-            self.fs[path] = ""
-            f = self.TestFile(self.fs, path, self.fs[path])
-        elif mode.endswith("a"):
-            if not path in self.fs:
-                self.fs[path] = ""
-            f = self.TestFile(self.fs, path, self.fs[path])
-            f.seek(0, os.SEEK_END)
-        elif content == None:
-            raise IOError("[Errno 2] No such file or directory: '%s'" % (path,))
-        elif mode.endswith("+"):
-            f = self.TestFile(self.fs, path, content)
-            if mode.startswith('r'):
-                f.seek(0, os.SEEK_SET)
-            else:
-                f.seek(0, os.SEEK_END)
-        else:
-            f = self.TestFile(self.fs, path, content)
-
-        return f
-
-    #Emulate os calls
-    def glob_glob(self, pattern):
-        return fnmatch.filter(self.fs.keys(), pattern)
-
-    def os_listdir(self, path):
-        return [entry[len(path):].lstrip('/') for entry in self.fs.keys()\
-                    if entry.startswith(path) and entry != path]
-
-    def os_path_exists(self, path):
-        path = os.path.join(self._pwd, path)
-        return self.fs.has_key(path)
-
-    def os_path_isdir(self, path):
-        if not path.endswith("/"):
-            path += "/"
-        path += "*"
-        return len(fnmatch.filter(self.fs.keys(), path)) > 0
-
-    def os_remove(self, path):
-        path = os.path.join(self._pwd, path)
-        try:
-            del self.fs[path]
-        except KeyError:
-            raise OSError("[Errno 2] No such file or directory: '%s'" % (path,))
-
-    def os_access(self, path, mode):
-        return self.os_path_exists(path)
diff --git a/tests/mock/mock.py b/tests/mock/mock.py
deleted file mode 100644
index 9053e81..0000000
--- a/tests/mock/mock.py
+++ /dev/null
@@ -1,271 +0,0 @@
-# mock.py
-# Test tools for mocking and patching.
-# Copyright (C) 2007-2009 Michael Foord
-# E-mail: fuzzyman AT voidspace DOT org DOT uk
-
-# mock 0.6.0
-# http://www.voidspace.org.uk/python/mock/
-
-# Released subject to the BSD License
-# Please see http://www.voidspace.org.uk/python/license.shtml
-
-# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
-# Comments, suggestions and bug reports welcome.
-
-
-__all__ = (
-    'Mock',
-    'patch',
-    'patch_object',
-    'sentinel',
-    'DEFAULT'
-)
-
-__version__ = '0.6.0'
-
-class SentinelObject(object):
-    def __init__(self, name):
-        self.name = name
-
-    def __repr__(self):
-        return '<SentinelObject "%s">' % self.name
-
-
-class Sentinel(object):
-    def __init__(self):
-        self._sentinels = {}
-
-    def __getattr__(self, name):
-        return self._sentinels.setdefault(name, SentinelObject(name))
-
-
-sentinel = Sentinel()
-
-DEFAULT = sentinel.DEFAULT
-
-class OldStyleClass:
-    pass
-ClassType = type(OldStyleClass)
-
-def _is_magic(name):
-    return '__%s__' % name[2:-2] == name
-
-def _copy(value):
-    if type(value) in (dict, list, tuple, set):
-        return type(value)(value)
-    return value
-
-
-class Mock(object):
-
-    def __init__(self, spec=None, side_effect=None, return_value=DEFAULT,
-                 name=None, parent=None, wraps=None):
-        self._parent = parent
-        self._name = name
-        if spec is not None and not isinstance(spec, list):
-            spec = [member for member in dir(spec) if not _is_magic(member)]
-
-        self._methods = spec
-        self._children = {}
-        self._return_value = return_value
-        self.side_effect = side_effect
-        self._wraps = wraps
-
-        self.reset_mock()
-
-
-    def reset_mock(self):
-        self.called = False
-        self.call_args = None
-        self.call_count = 0
-        self.call_args_list = []
-        self.method_calls = []
-        for child in self._children.itervalues():
-            child.reset_mock()
-        if isinstance(self._return_value, Mock):
-            self._return_value.reset_mock()
-
-
-    def __get_return_value(self):
-        if self._return_value is DEFAULT:
-            self._return_value = Mock()
-        return self._return_value
-
-    def __set_return_value(self, value):
-        self._return_value = value
-
-    return_value = property(__get_return_value, __set_return_value)
-
-
-    def __call__(self, *args, **kwargs):
-        self.called = True
-        self.call_count += 1
-        self.call_args = (args, kwargs)
-        self.call_args_list.append((args, kwargs))
-
-        parent = self._parent
-        name = self._name
-        while parent is not None:
-            parent.method_calls.append((name, args, kwargs))
-            if parent._parent is None:
-                break
-            name = parent._name + '.' + name
-            parent = parent._parent
-
-        ret_val = DEFAULT
-        if self.side_effect is not None:
-            if (isinstance(self.side_effect, Exception) or
-                isinstance(self.side_effect, (type, ClassType)) and
-                issubclass(self.side_effect, Exception)):
-                raise self.side_effect
-
-            ret_val = self.side_effect(*args, **kwargs)
-            if ret_val is DEFAULT:
-                ret_val = self.return_value
-
-        if self._wraps is not None and self._return_value is DEFAULT:
-            return self._wraps(*args, **kwargs)
-        if ret_val is DEFAULT:
-            ret_val = self.return_value
-        return ret_val
-
-
-    def __getattr__(self, name):
-        if self._methods is not None:
-            if name not in self._methods:
-                raise AttributeError("Mock object has no attribute '%s'" % name)
-        elif _is_magic(name):
-            raise AttributeError(name)
-
-        if name not in self._children:
-            wraps = None
-            if self._wraps is not None:
-                wraps = getattr(self._wraps, name)
-            self._children[name] = Mock(parent=self, name=name, wraps=wraps)
-
-        return self._children[name]
-
-
-    def assert_called_with(self, *args, **kwargs):
-        assert self.call_args == (args, kwargs), 'Expected: %s\nCalled with: %s' % ((args, kwargs), self.call_args)
-
-
-def _dot_lookup(thing, comp, import_path):
-    try:
-        return getattr(thing, comp)
-    except AttributeError:
-        __import__(import_path)
-        return getattr(thing, comp)
-
-
-def _importer(target):
-    components = target.split('.')
-    import_path = components.pop(0)
-    thing = __import__(import_path)
-
-    for comp in components:
-        import_path += ".%s" % comp
-        thing = _dot_lookup(thing, comp, import_path)
-    return thing
-
-
-class _patch(object):
-    def __init__(self, target, attribute, new, spec, create):
-        self.target = target
-        self.attribute = attribute
-        self.new = new
-        self.spec = spec
-        self.create = create
-        self.has_local = False
-
-
-    def __call__(self, func):
-        if hasattr(func, 'patchings'):
-            func.patchings.append(self)
-            return func
-
-        def patched(*args, **keywargs):
-            # don't use a with here (backwards compatability with 2.5)
-            extra_args = []
-            for patching in patched.patchings:
-                arg = patching.__enter__()
-                if patching.new is DEFAULT:
-                    extra_args.append(arg)
-            args += tuple(extra_args)
-            try:
-                return func(*args, **keywargs)
-            finally:
-                for patching in getattr(patched, 'patchings', []):
-                    patching.__exit__()
-
-        patched.patchings = [self]
-        patched.__name__ = func.__name__
-        patched.compat_co_firstlineno = getattr(func, "compat_co_firstlineno",
-                                                func.func_code.co_firstlineno)
-        return patched
-
-
-    def get_original(self):
-        target = self.target
-        name = self.attribute
-        create = self.create
-
-        original = DEFAULT
-        if _has_local_attr(target, name):
-            try:
-                original = target.__dict__[name]
-            except AttributeError:
-                # for instances of classes with slots, they have no __dict__
-                original = getattr(target, name)
-        elif not create and not hasattr(target, name):
-            raise AttributeError("%s does not have the attribute %r" % (target, name))
-        return original
-
-
-    def __enter__(self):
-        new, spec, = self.new, self.spec
-        original = self.get_original()
-        if new is DEFAULT:
-            # XXXX what if original is DEFAULT - shouldn't use it as a spec
-            inherit = False
-            if spec == True:
-                # set spec to the object we are replacing
-                spec = original
-                if isinstance(spec, (type, ClassType)):
-                    inherit = True
-            new = Mock(spec=spec)
-            if inherit:
-                new.return_value = Mock(spec=spec)
-        self.temp_original = original
-        setattr(self.target, self.attribute, new)
-        return new
-
-
-    def __exit__(self, *_):
-        if self.temp_original is not DEFAULT:
-            setattr(self.target, self.attribute, self.temp_original)
-        else:
-            delattr(self.target, self.attribute)
-        del self.temp_original
-
-
-def patch_object(target, attribute, new=DEFAULT, spec=None, create=False):
-    return _patch(target, attribute, new, spec, create)
-
-
-def patch(target, new=DEFAULT, spec=None, create=False):
-    try:
-        target, attribute = target.rsplit('.', 1)
-    except (TypeError, ValueError):
-        raise TypeError("Need a valid target to patch. You supplied: %r" % (target,))
-    target = _importer(target)
-    return _patch(target, attribute, new, spec, create)
-
-
-
-def _has_local_attr(obj, name):
-    try:
-        return name in vars(obj)
-    except TypeError:
-        # objects without a __dict__
-        return hasattr(obj, name)
diff --git a/tests/pyanaconda_test/Makefile.am b/tests/pyanaconda_test/Makefile.am
deleted file mode 100644
index 889d867..0000000
--- a/tests/pyanaconda_test/Makefile.am
+++ /dev/null
@@ -1,45 +0,0 @@
-# tests/pyanaconda_test/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Tomas Mlcoch <tmlcoch at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
-
-ANACDIR = $(top_builddir)/pyanaconda
-TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir)
-
-TESTS = backend_test.py \
-    bootloader_test.py \
-    cmdline_test.py \
-    desktop_test.py \
-    flags_test.py \
-    image_test.py \
-    language_test.py \
-    network_test.py \
-    packages_test.py \
-    packaging_test.py \
-    partintfhelpers_test.py \
-    product_test.py \
-    rescue_test.py \
-    security_test.py \
-    simpleconfig_test.py \
-    timezone_test.py \
-    upgrade_test.py \
-    users_test.py \
-    vnc_test.py
diff --git a/tests/pyanaconda_test/backend_test.py b/tests/pyanaconda_test/backend_test.py
deleted file mode 100644
index b09ee69..0000000
--- a/tests/pyanaconda_test/backend_test.py
+++ /dev/null
@@ -1,227 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class BackendTest(mock.TestCase):
-
-    def setUp(self):
-        import pykickstart.commands
-
-        self.setupModules(["_isys", "block", 'parted', 'storage',
-                    'pyanaconda.storage.formats', 'logging',
-                    'logging.config',
-                    'ConfigParser', 'pyanaconda.anaconda_log',
-                    'pyanaconda.storage.storage_log',
-                    'pyanaconda.yuminstall'])
-
-        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()
-        ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        ab.copyFirmware()
-        self.assertEqual(pyanaconda.backend.shutil.copyfile.call_args[0][0], FILE)
-
-    def anaconda_backend_do_post_install_test(self):
-        import pyanaconda.backend
-        from pyanaconda.constants import ROOT_PATH
-        FILE = 'foo'
-        A = 'a'
-        B = 'b'
-        C = 'c'
-        pyanaconda.backend.AnacondaBackend.copyFirmware = mock.Mock()
-        pyanaconda.backend.AnacondaBackend.kernelVersionList = mock.Mock(
-            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.extraModules = True
-
-        ab = pyanaconda.backend.AnacondaBackend(anaconda)
-        ab.doPostInstall(anaconda)
-
-        self.assertEqual(pyanaconda.backend.packages.method_calls[0],
-            ('recreateInitrd', (A, ROOT_PATH), {}))
-        self.assertEqual(pyanaconda.backend.shutil.method_calls[0],
-            ('copytree', (FILE, ROOT_PATH + '/root/'), {}))
-        self.assertEqual(pyanaconda.backend.shutil.method_calls[1],
-            ('copytree', (self.DD_EXTRACTED, ROOT_PATH + '/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()
-        anaconda = mock.Mock()
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        ab.getDefaultGroups(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)
-        ab.writeConfiguration()
-        self.assertTrue(self.logger.warning.called)
-
-    def do_backend_setup_1_test(self):
-        import pyanaconda.backend
-        RET = -1
-        pyanaconda.backend.DISPATCH_BACK = RET
-        anaconda = mock.Mock()
-        anaconda.backend.doBackendSetup.return_value = RET
-        ret = pyanaconda.backend.doBackendSetup(anaconda)
-        self.assertEqual(RET, ret)
-
-    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)
-
-    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/bootloader_test.py b/tests/pyanaconda_test/bootloader_test.py
deleted file mode 100644
index 6aa93bb..0000000
--- a/tests/pyanaconda_test/bootloader_test.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import mock
-
-class ArgumentsTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(
-            ['_isys', 'logging', 'pyanaconda.anaconda_log', 'block',
-             'pyanaconda.storage',
-             'pyanaconda.storage.devicelibs',
-             'pyanaconda.storage.errors'])
-
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def test_basic(self):
-        from pyanaconda.bootloader import Arguments
-        a = Arguments()
-        a.update(set(["a", "b", "c"]))
-        b = Arguments()
-        b.add("b")
-        diff = a - b
-        self.assertEqual(diff, set(["a", "c"]))
-        self.assertIsInstance(diff, Arguments)
-        assert(str(diff) in ["a c", "c a"])
-
-    def test_merge_ip(self):
-        from pyanaconda.bootloader import Arguments
-        # test that _merge_ip() doesnt break the simple case:
-        a = Arguments(["one", "two", "ip=eth0:dhcp"])
-        a._merge_ip()
-        self.assertEqual(a, Arguments(["one", "two", "ip=eth0:dhcp"]))
-
-        # test that it does what it's supposed to:
-        a = Arguments(["one", "two", "ip=eth0:dhcp", "ip=eth0:auto6",
-                       "ip=wlan0:dhcp",
-                       "ip=10.34.102.102::10.34.39.255:24:aklab:eth2:none"])
-        a._merge_ip()
-        self.assertEqual(a, set([
-                    "one", "two",
-                    "ip=wlan0:dhcp",
-                    "ip=10.34.102.102::10.34.39.255:24:aklab:eth2:none",
-                    "ip=eth0:auto6,dhcp"]))
-
-    def test_output_with_merge(self):
-        from pyanaconda.bootloader import Arguments
-        a = Arguments(["ip=eth0:dhcp"])
-        self.assertEqual(str(a), "ip=eth0:dhcp")
-        a = Arguments(["ip=eth0:dhcp", "ip=eth0:auto6"])
-        assert(str(a) in ["ip=eth0:auto6,dhcp", "ip=eth0:dhcp,auto6"])
-
-    def test_sorting(self):
-        from pyanaconda.bootloader import Arguments
-        a = Arguments(["ip=eth0:dhcp", "rhgb", "quiet",
-                       "root=/dev/mapper/destroyers-rubies", "rd.md=0",
-                       "rd.luks=0"])
-        # 'rhgb quiet' should be the final entries:
-        assert(str(a).endswith("rhgb quiet"))
diff --git a/tests/pyanaconda_test/desktop_test.py b/tests/pyanaconda_test/desktop_test.py
deleted file mode 100644
index 2078c9a..0000000
--- a/tests/pyanaconda_test/desktop_test.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-
-class DesktopTest(mock.TestCase):
-
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])
-        self.fs = mock.DiskIO()
-
-        self.fs.open('/mnt/sysimage/etc/inittab', 'w').write('id:5:initdefault:')
-        self.fs.open('/mnt/sysimage/etc/sysconfig/desktop', 'w').write('')
-
-        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()
-        dskt.setDefaultRunLevel(3)
-        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')
-
-    def write_1_test(self):
-        import pyanaconda.desktop
-        dskt = pyanaconda.desktop.Desktop()
-        dskt.write()
-        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
-                         'id:3:initdefault:')
-
-    def write_2_test(self):
-        import pyanaconda.desktop
-        dskt = pyanaconda.desktop.Desktop()
-        dskt.setDefaultRunLevel(5)
-        dskt.write()
-        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
-                         'id:5:initdefault:')
-
-    def write_3_test(self):
-        import pyanaconda.desktop
-        pyanaconda.desktop.os = mock.Mock()
-        pyanaconda.desktop.os.path.isdir.return_value = True
-        dskt = pyanaconda.desktop.Desktop()
-        dskt.setDefaultDesktop('foo')
-        dskt.write()
-        self.assertEqual(self.fs['/mnt/sysimage/etc/inittab'],
-                         'id:3:initdefault:')
-        self.assertEqual(self.fs['/mnt/sysimage/etc/sysconfig/desktop'],
-                         'DESKTOP="foo"\n')
-
diff --git a/tests/pyanaconda_test/flags_test.py b/tests/pyanaconda_test/flags_test.py
deleted file mode 100644
index e4046d5..0000000
--- a/tests/pyanaconda_test/flags_test.py
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/usr/bin/python
-
-# Test Bug 500198
-
-import mock
-import sys
-
-
-class FlagsTest(mock.TestCase):
-    """Simulate /proc/cmdline parameters parsing (#500198)"""
-
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])
-
-        self.fs = mock.DiskIO()
-
-        import pyanaconda.flags
-
-        self.mock2 = mock.Mock()
-        pyanaconda.flags.open = mock.Mock(return_value=self.mock2)
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def createcmdlinedict_1_test(self):
-        """/proc/cmdline without BOOT_IMAGE param"""
-        import pyanaconda.flags
-
-        self.cmd = 'vmlinuz initrd=initrd.img stage2=hd:LABEL="Fedora" xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        cmddict = pyanaconda.flags.flags.createCmdlineDict()
-
-        self.assertEqual(set(cmddict.keys()),
-            set(['vmlinuz', 'initrd', 'stage2', 'xdriver', 'nomodeset']))
-
-    def createcmdlinedict_2_test(self):
-        """/proc/cmdline param: quotes at end"""
-        import pyanaconda.flags
-
-        self.cmd = 'vmlinuz BOOT_IMAGE=/boot/img initrd=initrd.img stage2=hd:LABEL="Fedora"'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        try:
-            cmddict = pyanaconda.flags.flags.createCmdlineDict()
-        except (ValueError):
-            self.assertTrue(False, "ValueError exception was raised.")
-
-        self.assertEqual(set(cmddict.keys()),
-            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
-
-    def createcmdlinedict_3_test(self):
-        """/proc/cmdline param BOOT_IMAGE with quotes (no quotes at end)"""
-        import pyanaconda.flags
-
-        self.cmd = 'vmlinuz BOOT_IMAGE="img img" initrd=initrd.img'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        cmddict = pyanaconda.flags.flags.createCmdlineDict()
-
-        self.assertEqual(set(cmddict.keys()),
-            set(['vmlinuz', 'BOOT_IMAGE', 'initrd']))
-
-    def createcmdlinedict_4_test(self):
-        """/proc/cmdline param BOOT_IMAGE with quotes (no quotes at end) v2"""
-        import pyanaconda.flags
-
-        self.cmd = 'vmlinuz BOOT_IMAGE="/boot/img" stage2=hd:LABEL="Fedora" initrd=initrd.img'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        cmddict = pyanaconda.flags.flags.createCmdlineDict()
-
-        self.assertEqual(set(cmddict.keys()),
-            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
-
-    def createcmdlinedict_5_test(self):
-        """/proc/cmdline param: BOOT_IMAGE with quotes (+ quotes at end)"""
-        import pyanaconda.flags
-
-        self.cmd = 'vmlinuz BOOT_IMAGE="/boot/img img" initrd=initrd.img stage2=hd:LABEL="Fedora"'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        try:
-            cmddict = pyanaconda.flags.flags.createCmdlineDict()
-        except (ValueError):
-            self.assertTrue(False, "ValueError exception was raised.")
-
-        self.assertEqual(set(cmddict.keys()),
-            set(['vmlinuz', 'BOOT_IMAGE', 'initrd', 'stage2']))
-
-    def setattr_getattr_1_test(self):
-        import pyanaconda.flags
-        RET = 1
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        pyanaconda.flags.flags.sshd = RET
-        self.assertEqual(RET, pyanaconda.flags.flags.sshd)
-
-    def setattr_getattr_2_test(self):
-        import pyanaconda.flags
-        RET = 0
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        pyanaconda.flags.flags.sshd = RET
-        self.assertEqual(RET, pyanaconda.flags.flags.sshd)
-
-    def setattr_getattr_3_test(self):
-        import pyanaconda.flags
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-
-        def f(): return pyanaconda.flags.flags.fooattr
-        self.assertRaises(AttributeError, f)
-
-    def setattr_getattr_4_test(self):
-        import pyanaconda.flags
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-
-        def f(): pyanaconda.flags.flags.fooattr = 1
-        self.assertRaises(AttributeError, f)
-
-    def get_1_test(self):
-        import pyanaconda.flags
-        RET = 'text'
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        ret = pyanaconda.flags.flags.get('foobar', RET)
-        self.assertEqual(RET, ret)
-
-    def get_2_test(self):
-        import pyanaconda.flags
-        RET = 'text'
-        self.cmd = 'vmlinuz initrd=initrd.img xdriver=vesa nomodeset'
-        self.mock2.read = mock.Mock(return_value=self.cmd)
-        ret = pyanaconda.flags.flags.get('sshd', RET)
-        self.assertNotEqual(RET, ret)
diff --git a/tests/pyanaconda_test/image_test.py b/tests/pyanaconda_test/image_test.py
deleted file mode 100644
index f3faeac..0000000
--- a/tests/pyanaconda_test/image_test.py
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-
-IMAGENAME = 'Fedora-13-i386-DVD.iso'
-
-class ImageTest(mock.TestCase):
-    
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])            
-        self.fs = mock.DiskIO()
-        
-        DISCINFO = "1273712438.740122\n"
-        DISCINFO += "Fedora 13\n"
-        DISCINFO += "i386\n"
-        DISCINFO += "ALL\n"
-
-        DISCINFO2 = "1273712438.740122\n"
-        DISCINFO2 += "Fedora 13\n"
-        DISCINFO2 += "i386\n"
-        DISCINFO2 += "1,2\n"
-        
-        self.fs.open('/mnt/install/cdimage/.discinfo', 'w').write(DISCINFO)
-        self.fs.open('/tmp/.discinfo', 'w').write(DISCINFO2)
-        
-        import pyanaconda.image     
-        pyanaconda.image.gettext = mock.Mock()  
-        pyanaconda.image.log = mock.Mock()    
-        pyanaconda.image.open = self.fs.open
-        pyanaconda.image.isys = mock.Mock()
-        pyanaconda.image._arch = 'i386'
-        pyanaconda.image.stat = mock.Mock()
-        pyanaconda.image.stat.ST_SIZE = 0
-        
-        pyanaconda.image.os = mock.Mock()
-        pyanaconda.image.os.R_OK = 0
-        pyanaconda.image.os.stat.return_value = [2048]
-        pyanaconda.image.os.listdir.return_value=[IMAGENAME]
-    
-    def tearDown(self):
-        self.tearDownModules()
-        
-    def get_media_id_1_test(self):
-        import pyanaconda.image
-        ret = pyanaconda.image.getMediaId('/mnt/install/cdimage')
-        self.assertEqual(ret, '1273712438.740122') 
-        
-    def get_media_id_2_test(self):         
-        import pyanaconda.image
-        pyanaconda.image.os.access = mock.Mock(return_value=False)
-        ret = pyanaconda.image.getMediaId('/')
-        self.assertEqual(ret, None)      
-        
-    def mount_directory_1_test(self):   
-        import pyanaconda.image
-        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
-        pyanaconda.image.mountDirectory('hd:/dev/sda1:/', mock.Mock())
-        self.assertEqual(pyanaconda.image.isys.method_calls,
-            [('mount', ('/dev/sda1', '/mnt/install/isodir'), {'fstype': 'auto', 'options':''})])
-            
-    def mount_directory_2_test(self):   
-        import pyanaconda.image
-        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
-        pyanaconda.image.mountDirectory('hd:sda1:/', mock.Mock())
-        self.assertEqual(pyanaconda.image.isys.method_calls,
-            [('mount', ('/dev/sda1', '/mnt/install/isodir'), {'fstype': 'auto', 'options':''})])
-            
-    def mount_directory_3_test(self):   
-        import pyanaconda.image
-        pyanaconda.image.os.path.ismount = mock.Mock(return_value=True)
-        pyanaconda.image.mountDirectory('hd:sda1:/', mock.Mock())
-        self.assertEqual(pyanaconda.image.isys.method_calls, []) 
-        
-    def mount_image_1_test(self):
-        import pyanaconda.image
-        self.assertRaises(SystemError, pyanaconda.image.mountImage, '', '/mnt/install/cdimage', mock.Mock())
-     
-    def mount_image_2_test(self):
-        import pyanaconda.image
-        pyanaconda.image.os.path.ismount = mock.Mock(return_value=False)
-        ret = pyanaconda.image.mountImage('', '/mnt/install/cdimage', mock.Mock())
-
-        self.assertEqual(pyanaconda.image.isys.method_calls,
-           [('isIsoImage', ('/Fedora-13-i386-DVD.iso',), {}),
-            ('mount', ('/Fedora-13-i386-DVD.iso', '/mnt/install/cdimage'),
-                                    {'readOnly': True, 'fstype': 'iso9660'}),
-            ('umount', ('/mnt/install/cdimage',), {'removeDir': False}),
-            ('mount', ('/Fedora-13-i386-DVD.iso', '/mnt/install/cdimage'),
-                                    {'readOnly': True, 'fstype': 'iso9660'}),
-           ])
-        
-    def scan_for_media_1_test(self):
-        import pyanaconda.image
-        storage = mock.Mock()
-        storage.devicetree.devices = []
-        ret = pyanaconda.image.scanForMedia(mock.Mock(), storage)
-        self.assertEqual(ret, None)
-        
-    def scan_for_media_2_test(self):
-        import pyanaconda.image
-        device = mock.Mock()
-        device.type = 'cdrom'
-        device.name = 'deviceName'
-        storage = mock.Mock()
-        storage.devicetree.devices = [device]
-        ret = pyanaconda.image.scanForMedia('/tmp', storage)
-        self.assertEqual(ret, 'deviceName')
-        self.assertEqual(device.method_calls, 
-            [('format.mount', (), {'mountpoint': '/tmp'})])
-            
-    def umount_image_1_test(self):
-        import pyanaconda.image
-        pyanaconda.image.umountImage('/tmp')
-        self.assertEqual(pyanaconda.image.isys.method_calls, 
-            [('umount', ('/tmp',), {'removeDir': False})])
-             
-    def unmount_cd_1_test(self):
-        import pyanaconda.image
-        window = mock.Mock()
-        pyanaconda.image.unmountCD(None, window)
-        self.assertEqual(window.method_calls, [])
-
-    def unmount_cd_2_test(self):
-        import pyanaconda.image
-        window = mock.Mock()
-        device = mock.Mock()
-        pyanaconda.image.unmountCD(device, window)
-        self.assertEqual(window.method_calls, [])
-        self.assertEqual(device.method_calls,
-            [('format.unmount', (), {})])
-        
-    def verify_media_1_test(self):
-        import pyanaconda.image
-        ret = pyanaconda.image.verifyMedia('/tmp')
-        self.assertTrue(ret)
-        
-    def verify_media_2_test(self):
-        import pyanaconda.image
-        ret = pyanaconda.image.verifyMedia('/tmp', timestamp=1337)
-        self.assertFalse(ret)
-        
-    def verify_media_3_test(self):
-        import pyanaconda.image
-        pyanaconda.image._arch = 'x86_64'
-        ret = pyanaconda.image.verifyMedia('/tmp', 1)
-        self.assertFalse(ret)
diff --git a/tests/pyanaconda_test/indexed_dict_test.py b/tests/pyanaconda_test/indexed_dict_test.py
deleted file mode 100644
index 14185b6..0000000
--- a/tests/pyanaconda_test/indexed_dict_test.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import mock
-
-class IndexedDictTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(['_isys'])
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def instantiation_test(self):
-        from pyanaconda.indexed_dict import IndexedDict
-        d = IndexedDict()
-        self.assertIsInstance(d, IndexedDict)
-
-    def append_test(self):
-        from pyanaconda.indexed_dict import IndexedDict
-        d = IndexedDict()
-        stored_data = [1, 2, 3]
-        d["some_step"] = stored_data
-        self.assertIs(d["some_step"], stored_data)
-
-    def cant_append_test(self):
-        from pyanaconda.indexed_dict import IndexedDict
-        def assign_int(indexed_dict):
-            indexed_dict[3] = [1, 2, 3]
-        d = IndexedDict()
-        self.assertRaises(TypeError, d.__setitem__, 3, [1, 2, 3])
-
-    def referencing_test(self):
-        from pyanaconda.indexed_dict import IndexedDict
-        d = IndexedDict()
-        d["first"] = 10
-        d["second"] = 20
-        d["third"] = 30
-        self.assertEqual(d[0], 10)
-        self.assertEqual(d[1], 20)
-        self.assertEqual(d[2], 30)
-        self.assertRaises(IndexError, d.__getitem__, 3)
-
-    def index_test(self):
-        from pyanaconda.indexed_dict import IndexedDict
-        d = IndexedDict()
-        d["first"] = 10
-        d["second"] = 20
-        d["third"] = 30
-
-        self.assertEqual(d.index("first"), 0)
-        self.assertEqual(d.index("second"), 1)
-        self.assertEqual(d.index("third"), 2)
diff --git a/tests/pyanaconda_test/iutil_test.py b/tests/pyanaconda_test/iutil_test.py
deleted file mode 100644
index 2f143ec..0000000
--- a/tests/pyanaconda_test/iutil_test.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import mock
-import sys
-
-class IutilTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(
-            ['_isys', 'logging', 'pyanaconda.anaconda_log', 'block'])
-
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def copy_to_sysimage_test(self):
-        from pyanaconda import iutil
-        fs = mock.DiskIO()
-        self.take_over_io(fs, iutil)
-        self.assertEqual(iutil.copy_to_sysimage("/etc/securetty"), False)
-
-        fs["/etc/securetty"] = "tty1"
-        iutil.os.makedirs = mock.Mock()
-        iutil.shutil.copy = mock.Mock()
-        self.assertEqual(iutil.copy_to_sysimage("/etc/securetty"), True)
-        iutil.os.makedirs.assert_called_with("/mnt/sysimage/etc")
-        iutil.shutil.copy.assert_called_with("/etc/securetty",
-                                             "/mnt/sysimage/etc/securetty")
-
-    def testExecCaptureNonZeroFatal (self):
-        import iutil
-        try:
-            argv = ["-c", "import sys; sys.exit(3);"]
-            iutil.execWithCapture(sys.executable, argv, root=None, fatal=True)
-        except RuntimeError, ex:
-            self.assertIn("return code: 3", str(ex))
-        else:
-            self.fail("RuntimeError not raised")
diff --git a/tests/pyanaconda_test/network_test.py b/tests/pyanaconda_test/network_test.py
deleted file mode 100644
index 756c11d..0000000
--- a/tests/pyanaconda_test/network_test.py
+++ /dev/null
@@ -1,389 +0,0 @@
-#!/usr/bin/python
-
-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
-        pyanaconda.network.open = self.fs.open
-        pyanaconda.simpleconfig.open = self.fs.open
-        pyanaconda.network.sysconfigDir = self.SYSCONFIGDIR
-        pyanaconda.network.netscriptsDir = self.NETSCRIPTSDIR
-        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.setNMControlledDevices_backup = pyanaconda.network.Network.setNMControlledDevices
-        pyanaconda.network.Network.setNMControlledDevices = mock.Mock()
-        pyanaconda.network.Network.netdevices = {}
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def sanity_check_hostname_1_test(self):
-        import pyanaconda.network
-        (valid, err) = pyanaconda.network.sanityCheckHostname('desktop')
-        self.assertTrue(valid)
-
-    def sanity_check_hostname_2_test(self):
-        import pyanaconda.network
-        (valid, err) = pyanaconda.network.sanityCheckHostname('')
-        self.assertFalse(valid)
-
-    def sanity_check_hostname_3_test(self):
-        import pyanaconda.network
-        (valid, err) = pyanaconda.network.sanityCheckHostname('c'*256)
-        self.assertFalse(valid)
-
-    def sanity_check_hostname_4_test(self):
-        import pyanaconda.network
-        (valid, err) = pyanaconda.network.sanityCheckHostname('_asf')
-        self.assertFalse(valid)
-
-    def sanity_check_hostname_5_test(self):
-        import pyanaconda.network
-        (valid, err) = pyanaconda.network.sanityCheckHostname('a?f')
-        self.assertFalse(valid)
-
-    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()
-        pyanaconda.network.socket = mock.Mock()
-        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,
-            pyanaconda.network.sanityCheckIPString, IPADDR)
-
-    def sanity_check_ip_string_4_test(self):
-        import pyanaconda.network
-        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
-        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,
-            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 = \
-            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 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',
-            '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()
-        self.assertEqual(nd.info, {})
-
-    def networkdevice_str_test(self):
-        import pyanaconda.network
-        pyanaconda.network.arch = mock.Mock()
-        pyanaconda.network.arch.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.assertIn('DEVICE="eth0"', str(nd))
-        self.assertIn('TYPE="Ethernet"', str(nd))
-
-    def networkdevice_load_ifcfg_file_test(self):
-        import pyanaconda.network
-        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
-        nd.loadIfcfgFile()
-        self.assertFalse(nd._dirty)
-        self.assertEqual(nd.info,
-            {'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.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)
-        nd.set(('key', 'value'))
-        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)
-        nd.set(('key', 'value'))
-        nd._dirty = False
-        nd.set(('key', 'other_value'))
-        self.assertEqual(nd.info, {'KEY': 'other_value'})
-        self.assertTrue(nd._dirty)
-
-    def networkdevice_set_gateway_test(self):
-        import pyanaconda.network
-        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
-        nd.setGateway('10.0.0.1')
-        self.assertEqual(nd.info, {'GATEWAY': '10.0.0.1'})
-        self.assertTrue(nd._dirty)
-
-    def networkdevice_set_gateway_ipv6_test(self):
-        import pyanaconda.network
-        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
-        nd.setGateway('fe80::5675:d0ff:feac:4d3f')
-        self.assertEqual(nd.info, {'IPV6_DEFAULTGW': 'fe80::5675:d0ff:feac:4d3f'})
-        self.assertTrue(nd._dirty)
-
-    def networkdevice_set_dns_test(self):
-        import pyanaconda.network
-        nd = pyanaconda.network.NetworkDevice(self.NETSCRIPTSDIR, self.DEVICE)
-        nd.setDNS('10.0.0.1, 10.0.0.2')
-        self.assertEqual(nd.info, {'DNS1': '10.0.0.1'})
-        self.assertEqual(nd.info, {'DNS2': '10.0.0.2'})
-        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'
-        TMP_DIR = '/tmp/wepkeyfiles'
-        pyanaconda.network.tempfile = mock.Mock()
-        pyanaconda.network.tempfile.mkstemp.return_value = (88, TMP_FILE)
-        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 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,
-            [('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,
-            [('set', (('NM_CONTROLLED', 'no'),), {})])
-
-    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],
-            'network --device eth0 --bootproto dhcp --noipv6\n')
-
-    def network_wait_for_connection_1_test(self):
-        import pyanaconda.network
-        pyanaconda.network.dbus = mock.Mock()
-        pyanaconda.network.dbus.Interface().Get.return_value = \
-            pyanaconda.network.isys.NM_STATE_CONNECTED_GLOBAL
-
-        ret = pyanaconda.network.waitForConnection()
-        self.assertTrue(ret)
-
-    def network_wait_for_connection_2_test(self):
-        import pyanaconda.network
-        pyanaconda.network.dbus = mock.Mock()
-        pyanaconda.network.dbus.Interface().Get.return_value = self.OK-5
-        pyanaconda.network.isys = mock.Mock()
-        pyanaconda.network.isys.NM_STATE_CONNECTED = self.OK
-        pyanaconda.network.time.sleep = mock.Mock()
-
-        ret = pyanaconda.network.waitForConnection()
-        self.assertFalse(ret)
-
-    def network_bring_up_test(self):
-        import pyanaconda.network
-        pyanaconda.network.Network.write = mock.Mock()
-        pyanaconda.network.waitForConnection = mock.Mock()
-
-        nw = pyanaconda.network.Network()
-        nw.bringUp()
-        self.assertTrue(pyanaconda.network.Network.write.called)
-        self.assertTrue(pyanaconda.network.waitForConnection.called)
-
-    def iface_for_host_ip_test(self):
-        import pyanaconda.network
-        pyanaconda.network.arch = mock.Mock()
-        pyanaconda.network.arch.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/packages_test.py b/tests/pyanaconda_test/packages_test.py
deleted file mode 100644
index 18de7ab..0000000
--- a/tests/pyanaconda_test/packages_test.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class PackagesTest(mock.TestCase):
-    
-    def setUp(self):
-        self.setupModules(["_isys", "block", "logging", "parted", "storage", 
-                    "pyanaconda.storage.formats", "ConfigParser", 
-                    "pyanaconda.storage.storage_log"])
-        self.fs = mock.DiskIO()
-        
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-
-        import pyanaconda.packages
-        
-    def tearDown(self):
-        self.tearDownModules()
-    
-    def do_post_action_test(self):
-        import pyanaconda.packages
-        anaconda = mock.Mock()
-        pyanaconda.packages.doPostAction(anaconda)
-        self.assertTrue(anaconda.instClass.postAction.called)
diff --git a/tests/pyanaconda_test/packaging_test.py b/tests/pyanaconda_test/packaging_test.py
deleted file mode 100644
index 99bc871..0000000
--- a/tests/pyanaconda_test/packaging_test.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class PackagingTest(mock.TestCase):
-    
-    def setUp(self):
-        self.setupModules(["_isys", "logging"])
-        
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-
-        from pykickstart.version import makeVersion
-        from pyanaconda.flags import flags
-
-        # set some things specially since we're just testing
-        flags.testing = True
-
-        # set up ksdata
-        self.ksdata = makeVersion()
-
-        from pyanaconda.packaging import Payload
-        self.payload = Payload(self.ksdata)
-
-    def tearDown(self):
-        self.tearDownModules()
-        #os.system("rm -rf %s" % self.root)
-
-    def payload_abstract_test(self):
-        self.assertRaises(NotImplementedError, self.payload.setup, None)
-        self.assertRaises(NotImplementedError, self.payload.description, None)
-
-    def payload_repo_test(self):
-        # ksdata repo list initially empty
-        self.assertEqual(self.payload.data.repo.dataList(), [])
-
-        # create and add a new ksdata repo
-        repo_name = "test1"
-        repo = self.ksdata.RepoData(name=repo_name, baseurl="http://localhost/")
-        self.payload.addRepo(repo)
-
-        # verify the repo was added
-        self.assertEqual(self.payload.data.repo.dataList(), [repo])
-        self.assertEqual(self.payload.getAddOnRepo(repo_name), repo)
-
-        # remove the repo
-        self.payload.removeRepo(repo_name)
-
-        # verify the repo was removed
-        self.assertEqual(self.payload.getAddOnRepo(repo_name), None)
-
-    def payload_group_test(self):
-        import pykickstart.constants
-        from pykickstart.parser import Group
-
-        # verify that ksdata group lists are initially empty
-        self.assertEqual(self.payload.data.packages.groupList, [])
-        self.assertEqual(self.payload.data.packages.excludedGroupList, [])
-
-        self.payload.deselectGroup("core")
-        self.assertEqual(self.payload.groupSelected("core"), False)
-
-        # select a group and verify the selection is reflected afterward
-        self.payload.selectGroup("core", optional=True)
-        self.assertTrue(self.payload.groupSelected("core"))
-
-        # verify the group is not in the excluded group list
-        self.assertTrue(Group("core") not in self.payload.data.packages.excludedGroupList)
-
-        # verify the include (optional/all) is recorded
-        groups = self.payload.data.packages.groupList
-        group = groups[[g.name for g in groups].index("core")]
-        self.assertEqual(group.include, pykickstart.constants.GROUP_ALL)
-
-        # select more groups
-        self.payload.selectGroup("base")
-        self.payload.selectGroup("development", default=False)
-
-        # verify include types for newly selected groups
-        group = groups[[g.name for g in groups].index("development")]
-        self.assertEqual(group.include, pykickstart.constants.GROUP_REQUIRED)
-
-        group = groups[[g.name for g in groups].index("base")]
-        self.assertEqual(group.include, pykickstart.constants.GROUP_DEFAULT)
-
-        # deselect a group and verify the set of groups is correct afterward
-        self.payload.deselectGroup("base")
-        self.assertFalse(self.payload.groupSelected("base"))
-        self.assertTrue(self.payload.groupSelected("core"))
-        self.assertTrue(self.payload.groupSelected("development"))
-
-    def payload_package_test(self):
-        # verify that ksdata package lists are initially empty
-        self.assertEqual(self.payload.data.packages.packageList, [])
-        self.assertEqual(self.payload.data.packages.excludedList, [])
-
-        name = "vim-common"
-
-        # deselect a package
-        self.payload.deselectPackage(name)
-        self.assertEqual(self.payload.packageSelected(name), False)
-
-        # select the same package and verify it
-        self.payload.selectPackage(name)
-        self.assertEqual(self.payload.packageSelected(name), True)
-        self.assertTrue(name in self.payload.data.packages.packageList)
-        self.assertFalse(name in self.payload.data.packages.excludedList)
-
-        # select some other packages
-        self.payload.selectPackage("bash")
-        self.payload.selectPackage("gnote")
-
-        # deselect one of them and then verify the selection state of them all
-        self.payload.deselectPackage("bash")
-        self.assertFalse(self.payload.packageSelected("bash"))
-        self.assertTrue(self.payload.packageSelected("gnote"))
-        self.assertTrue(self.payload.packageSelected(name))
-
-    def payload_get_release_version_test(self):
-        # Given no URL, _getReleaseVersion should be able to get a releasever
-        # from pyanaconda.constants.productVersion. This trickery is due to the
-        # fact that pyanaconda/packaging/__init__.py will have already imported
-        # productVersion from pyanaconda.constants.
-        import pyanaconda.packaging
-        pyanaconda.packaging.productVersion = "17-Beta"
-        self.assertEqual(self.payload._getReleaseVersion(None), "17")
diff --git a/tests/pyanaconda_test/partintfhelpers_test.py b/tests/pyanaconda_test/partintfhelpers_test.py
deleted file mode 100644
index efc0680..0000000
--- a/tests/pyanaconda_test/partintfhelpers_test.py
+++ /dev/null
@@ -1,480 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class PartIntfHelpersTest(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.partIntfHelpers
-          
-    def tearDown(self):
-        self.tearDownModules()
-
-    # sanityCheckVolumeGroupName tests
-
-    def sanitycheckvolumegroupname_right_hostname_1_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = "hostname"
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_right_hostname_2_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = "h"
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_right_hostname_3_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = "a" * 127
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_right_hostname_4_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = "h-o_s-t.name"
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_empty_hostname_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = ""
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_long_hostname_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = "asdfasdfas" * 13
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_1_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = 'lvm'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_2_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = 'root'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_3_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = '.'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_4_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = '..'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_5_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = 'foo bar'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckvolumegroupname_bad_hostname_6_test(self):
-        import pyanaconda.partIntfHelpers
-        HOSTNAME = 'foob at r'
-        ret = pyanaconda.partIntfHelpers.sanityCheckVolumeGroupName(HOSTNAME)
-        self.assertNotEqual(ret, None)
-    
-    # sanityCheckLogicalVolumeName test
-    
-    def sanitychecklogicalvolumename_right_name_1_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "name"
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_right_name_2_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "name_00.9"
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_right_name_3_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "a"
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_empty_name_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = ""
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_long_name_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "b" * 129
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_bad_name_1_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "group"
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_bad_name_2_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = "."
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_bad_name_3_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = ".."
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_bad_name_4_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = 'foo bar'
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    def sanitychecklogicalvolumename_bad_name_5_test(self):
-        import pyanaconda.partIntfHelpers
-        LOGVOLNAME = 'foob at r'
-        ret = pyanaconda.partIntfHelpers.sanityCheckLogicalVolumeName(LOGVOLNAME)
-        self.assertNotEqual(ret, None)
-    
-    # sanityCheckMountPoint test
-    
-    def sanitycheckmountpoint_right_name_1_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/foob at r'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckmountpoint_right_name_2_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/var'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckmountpoint_right_name_3_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertEqual(ret, None)
-    
-    def sanitycheckmountpoint_bad_name_1_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '//'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-        
-    def sanitycheckmountpoint_bad_name_2_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/foo bar'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckmountpoint_bad_name_3_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/./'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckmountpoint_bad_name_4_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/../'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckmountpoint_bad_name_5_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/..'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-    
-    def sanitycheckmountpoint_bad_name_6_test(self):
-        import pyanaconda.partIntfHelpers
-        MNTPT = '/.'
-        ret = pyanaconda.partIntfHelpers.sanityCheckMountPoint(MNTPT)
-        self.assertNotEqual(ret, None)
-    
-    def dodeletedevice_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        STORAGE = mock.Mock()
-        DEVICE = None
-        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
-        self.assertFalse(ret)
-    
-    def dodeletedevice_2_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        STORAGE = mock.Mock()
-        STORAGE.deviceImmutable.return_value = True
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
-        self.assertFalse(ret)
-    
-    def dodeletedevice_3_test(self):
-        import pyanaconda.partIntfHelpers
-        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=False)
-        INTF = mock.Mock()
-        STORAGE = mock.Mock()
-        STORAGE.deviceImmutable.return_value = False
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
-        self.assertFalse(ret)
-    
-    def dodeletedevice_4_test(self):
-        import pyanaconda.partIntfHelpers
-        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=False)
-        INTF = mock.Mock()
-        STORAGE = mock.Mock()
-        STORAGE.deviceImmutable.return_value = False
-        STORAGE.deviceDeps.return_value = []
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE,
-                                                        confirm=0)
-        self.assertTrue(ret)
-        self.assertTrue(STORAGE.destroyDevice.called)
-    
-    def dodeletedevice_5_test(self):
-        import pyanaconda.partIntfHelpers
-        pyanaconda.partIntfHelpers.confirmDelete = mock.Mock(return_value=True)
-        INTF = mock.Mock()
-        STORAGE = mock.Mock()
-        STORAGE.deviceImmutable.return_value = False
-        STORAGE.deviceDeps.return_value = []
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doDeleteDevice(INTF, STORAGE, DEVICE)
-        self.assertTrue(ret)
-        self.assertTrue(STORAGE.destroyDevice.called)
-    
-    def doclearpartitioneddevice_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = 0
-        STORAGE = mock.Mock()
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
-                                                                  DEVICE)
-        self.assertFalse(ret)
-    
-    def doclearpartitioneddevice_2_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = 1
-        STORAGE = mock.Mock()
-        STORAGE.partitions = []
-        DEVICE = mock.Mock()
-        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
-                                                                  DEVICE)
-        self.assertFalse(ret)
-    
-    def doclearpartitioneddevice_3_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = 1
-        DEVICE = mock.Mock()
-        p = mock.Mock()
-        p.disk = DEVICE
-        p.partedPartition.number = 0
-        STORAGE = mock.Mock()
-        STORAGE.partitions = [p]
-        STORAGE.deviceImmutable.return_value = False
-        STORAGE.deviceDeps.return_value = []
-        
-        ret = pyanaconda.partIntfHelpers.doClearPartitionedDevice(INTF, STORAGE,
-                                                                  DEVICE)
-        self.assertTrue(ret)
-    
-    def checkforswapnomatch_test(self):
-        import pyanaconda.partIntfHelpers
-        pyanaconda.partIntfHelpers.parted.PARTITION_SWAP = 5
-        device = mock.Mock()
-        device.exists.return_value = True
-        device.getFlag.return_value = True
-        device.format.type == "swap"
-        ANACONDA = mock.Mock()
-        ANACONDA.storage.partitions = [device]
-        ANACONDA.intf.messageWindow.return_value = 1
-        pyanaconda.partIntfHelpers.checkForSwapNoMatch(ANACONDA)
-        self.assertTrue(ANACONDA.storage.formatDevice.called)
-    
-    def musthaveselecteddrive_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        pyanaconda.partIntfHelpers.mustHaveSelectedDrive(INTF)
-        self.assertTrue(INTF.messageWindow.called)
-    
-    def querynoformatpreexisting_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 22
-        INTF = mock.Mock()
-        ret = INTF.messageWindow.return_value = RET
-        self.assertEqual(RET, ret)
-    
-    def partitionsanityerrors_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        ERRORS = []
-        ret = pyanaconda.partIntfHelpers.partitionSanityErrors(INTF, ERRORS)
-        self.assertEqual(1, ret)
-    
-    def partitionsanityerrors_2_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 5
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        ERRORS = ['err string', 'foo string']
-        ret = pyanaconda.partIntfHelpers.partitionSanityErrors(INTF, ERRORS)
-        self.assertEqual(RET, ret)
-        self.assertTrue(ERRORS[0] in INTF.messageWindow.call_args[0][1])
-        self.assertTrue(ERRORS[1] in INTF.messageWindow.call_args[0][1])
-    
-    def partitionsanitywarnings_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        WARNINGS = []
-        ret = pyanaconda.partIntfHelpers.partitionSanityWarnings(INTF, WARNINGS)
-        self.assertEqual(1, ret)
-    
-    def partitionsanitywarnings_2_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 5
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        WARNINGS = ['warning string', 'foo string']
-        ret = pyanaconda.partIntfHelpers.partitionSanityWarnings(INTF, WARNINGS)
-        self.assertEqual(RET, ret)
-        self.assertTrue(WARNINGS[0] in INTF.messageWindow.call_args[0][1])
-        self.assertTrue(WARNINGS[1] in INTF.messageWindow.call_args[0][1])
-    
-    def partitionpreexistformatwarnings_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        WARNINGS = []
-        ret = pyanaconda.partIntfHelpers.partitionPreExistFormatWarnings(INTF, WARNINGS)
-        self.assertEqual(1, ret)
-    
-    def partitionpreexistformatwarnings_2_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 10
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        WARNINGS = [('foo', 'foobar', '/foodir')]
-        ret = pyanaconda.partIntfHelpers.partitionPreExistFormatWarnings(INTF, WARNINGS)
-        self.assertEqual(RET, ret)
-        self.assertTrue(WARNINGS[0][0] in INTF.messageWindow.call_args[0][1])
-    
-    def getpreexistformatwarnings_1_test(self):
-        import pyanaconda.partIntfHelpers
-        STORAGE = mock.Mock()
-        STORAGE.devicetree.devices = []
-        ret = pyanaconda.partIntfHelpers.getPreExistFormatWarnings(STORAGE)
-        self.assertEqual([], ret)
-    
-    def getpreexistformatwarnings_2_test(self):
-        import pyanaconda.partIntfHelpers
-        STORAGE = mock.Mock()
-        device = mock.Mock()
-        device.exists = True
-        device.name = 'foodev'
-        device.path = '/foodevdir'
-        device.format.name = 'fffoodev'
-        device.format.mountpoint = '/mnt/foo'
-        device.format.exists = False
-        device.format.hidden = False
-        STORAGE.devicetree.devices = [device]
-        ret = pyanaconda.partIntfHelpers.getPreExistFormatWarnings(STORAGE)
-        self.assertEqual([('/foodevdir', 'fffoodev', '/mnt/foo')], ret)
-    
-    def confirmdelete_1_test(self):
-        import pyanaconda.partIntfHelpers
-        INTF = mock.Mock()
-        DEVICE = False
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(None, ret)
-    
-    def confirmdelete_2_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 51
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        DEVICE = mock.Mock()
-        DEVICE.type = "lvmvg"
-        DEVICE.name = "devname"
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(RET, ret)
-        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
-    
-    def confirmdelete_3_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 52
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        DEVICE = mock.Mock()
-        DEVICE.type = "lvmlv"
-        DEVICE.name = "devname"
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(RET, ret)
-        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
-    
-    def confirmdelete_4_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 53
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        DEVICE = mock.Mock()
-        DEVICE.type = "mdarray"
-        DEVICE.name = "devname"
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(RET, ret)
-    
-    def confirmdelete_5_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 54
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        DEVICE = mock.Mock()
-        DEVICE.type = "partition"
-        DEVICE.name = "devname"
-        DEVICE.path = "/dev/devname"
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(RET, ret)
-        self.assertTrue(DEVICE.path in INTF.messageWindow.call_args[0][1])
-    
-    def confirmdelete_6_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 55
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        DEVICE = mock.Mock()
-        DEVICE.type = "other"
-        DEVICE.name = "devname"
-        ret = pyanaconda.partIntfHelpers.confirmDelete(INTF, DEVICE)
-        self.assertEqual(RET, ret)
-        self.assertTrue(DEVICE.type in INTF.messageWindow.call_args[0][1])
-        self.assertTrue(DEVICE.name in INTF.messageWindow.call_args[0][1])
-    
-    def confirmresetpartitionstate_test(self):
-        import pyanaconda.partIntfHelpers
-        RET = 61
-        INTF = mock.Mock()
-        INTF.messageWindow.return_value = RET
-        ret = pyanaconda.partIntfHelpers.confirmResetPartitionState(INTF)
-        self.assertEqual(RET, ret)
-    
diff --git a/tests/pyanaconda_test/product_test.py b/tests/pyanaconda_test/product_test.py
deleted file mode 100644
index 9b0d864..0000000
--- a/tests/pyanaconda_test/product_test.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-import __builtin__
-
-import ConfigParser
-
-class ProductTest(mock.TestCase):
-
-    def setUp(self):
-        self.setupModules(['_isys', 'block', 'os'])
-        self.fs = mock.DiskIO()
-
-        # 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 = {}
-
-        # fake /tmp/product/.buildstamp file
-        self.BUGURL = 'http://bug.url'
-        self.FINAL = 'false'
-        self.ARCH = 'i386'
-        self.NAME = '__anaconda'
-        self.UUID = '123456.%s' % self.ARCH
-        self.VERSION = '14'
-        self.FILENAME = '/tmp/product/.buildstamp'
-        self.FILE = \
-        "[Main]\n"\
-        "BugURL: %s\n"\
-        "IsFinal: %s\n"\
-        "Arch: %s\n"\
-        "Product: %s\n"\
-        "UUID: %s\n"\
-        "Version: %s\n" % \
-        (self.BUGURL, self.FINAL, 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
-
-        if 'pyanaconda.product' in sys.modules:
-            del(sys.modules["pyanaconda.product"])
-
-    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_final_test(self):
-        sys.modules['os'].access = mock.Mock(return_value=True)
-        import pyanaconda.product
-        self.assertFalse(pyanaconda.product.isFinal)
-
-    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
-        self.assertEqual(pyanaconda.product.productName, self.NAME)
-
-    def product_stamp_test(self):
-        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
-        self.assertEqual(pyanaconda.product.productVersion, self.VERSION)
-
diff --git a/tests/pyanaconda_test/rescue_test.py b/tests/pyanaconda_test/rescue_test.py
deleted file mode 100644
index b93f75e..0000000
--- a/tests/pyanaconda_test/rescue_test.py
+++ /dev/null
@@ -1,297 +0,0 @@
-#!/usr/bin/python
-
-import mock
-
-class RescueTest(mock.TestCase):
-
-    def setUp(self):
-        self.setupModules(
-            ['_isys', 'block', 'parted', 'storage', 'pyanaconda.storage.formats',
-             'logging', 'add_drive_text', 'ConfigParser',
-             'pyanaconda.storage.storage_log', 'pyanaconda.anaconda_log', 'snack'
-             ])
-
-        self.fs = mock.DiskIO()
-
-        import pyanaconda
-        pyanaconda.anaconda_log = mock.Mock()
-        import snack
-        snack.SnackScreen = mock.Mock()
-
-        import pyanaconda.rescue
-        pyanaconda.rescue.open = self.fs.open
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    #
-    # RescueInterface class tests
-    #
-
-    def rescueinterface_waitwindow_test(self):
-        import pyanaconda.rescue
-        RET = 'foo1'
-        pyanaconda.rescue.WaitWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.waitWindow(TITLE, TEXT)
-        self.assertEqual(ret, RET)
-
-    def rescueinterface_progresswindow_test(self):
-        import pyanaconda.rescue
-        RET = 'foo2'
-        pyanaconda.rescue.ProgressWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        TOTAL = 100
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.progressWindow(TITLE, TEXT, TOTAL)
-        self.assertEqual(ret, RET)
-
-    def rescueinterface_detailedmessagewindow_test(self):
-        import pyanaconda.rescue
-        RET = 'foo3'
-        pyanaconda.rescue.RescueInterface.messageWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.detailedMessageWindow(TITLE, TEXT)
-        self.assertEqual(ret, RET)
-
-    def rescueinterface_messagewindow_1_test(self):
-        import pyanaconda.rescue
-        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock()
-        TITLE = 'title'
-        TEXT = 'text'
-        TYPE = 'ok'
-        ri = pyanaconda.rescue.RescueInterface()
-        ri.detailedMessageWindow(TITLE, TEXT, TYPE)
-        self.assertTrue(pyanaconda.rescue.ButtonChoiceWindow.called)
-
-    def rescueinterface_messagewindow_2_test(self):
-        import pyanaconda.rescue
-        RET='yes'
-        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        TYPE = 'yesno'
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.messageWindow(TITLE, TEXT, TYPE)
-        self.assertEqual(ret, 1)
-
-    def rescueinterface_messagewindow_3_test(self):
-        import pyanaconda.rescue
-        RET = 'barfoo'
-        pyanaconda.rescue.ButtonChoiceWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        TYPE = 'custom'
-        CUSTOM_BUTT = ['foo_bar', 'bar_foo']
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.messageWindow(TITLE, TEXT, TYPE, custom_buttons=CUSTOM_BUTT)
-        self.assertEqual(ret, 1)
-
-    def rescueinterface_messagewindow_4_test(self):
-        import pyanaconda.rescue
-        RET = 'foo4'
-        pyanaconda.rescue.OkCancelWindow = mock.Mock(return_value=RET)
-        TITLE = 'title'
-        TEXT = 'text'
-        TYPE = 'otherfoo'
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.messageWindow(TITLE, TEXT, TYPE)
-        self.assertEqual(ret, RET)
-
-    def rescueinterface_enablenetwork_1_test(self):
-        import pyanaconda.rescue
-        anaconda = mock.Mock()
-        anaconda.network.netdevices = {}
-
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.enableNetwork(anaconda)
-        self.assertFalse(ret)
-
-    def rescueinterface_passphraseentrywindow_test(self):
-        import pyanaconda.rescue
-        RET = ('secret', False)
-        pyanaconda.rescue.PassphraseEntryWindow = mock.Mock()
-        pyanaconda.rescue.PassphraseEntryWindow().run.return_value = RET
-        DEVICE = 'dev'
-
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.passphraseEntryWindow(DEVICE)
-        self.assertEqual(ret, RET)
-        self.assertTrue(pyanaconda.rescue.PassphraseEntryWindow().pop.called)
-
-    def rescueinterface_resetinitializediskquestion_test(self):
-        import pyanaconda.rescue
-        ri = pyanaconda.rescue.RescueInterface()
-        ri._initLabelAnswers = {'foo': 'bar'}
-        ri.resetInitializeDiskQuestion()
-
-    def rescueinterface_resetreinitinconsistentlvmquestion_test(self):
-        import pyanaconda.rescue
-        ri = pyanaconda.rescue.RescueInterface()
-        ri._inconsistentLVMAnswers = {'foo': 'bar'}
-        ri.resetReinitInconsistentLVMQuestion()
-        self.assertEqual(ri._inconsistentLVMAnswers, {})
-
-    def rescueinterface_questioninitializedisk_test(self):
-        import pyanaconda.rescue
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.questionInitializeDisk('/', '', 0)
-        self.assertFalse(ret)
-
-    def rescueinterface_questionreinitinconsistentlvm_test(self):
-        import pyanaconda.rescue
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.questionReinitInconsistentLVM()
-        self.assertFalse(ret)
-
-    def rescueinterface_questioninitializedasd_test(self):
-        import pyanaconda.rescue
-        ri = pyanaconda.rescue.RescueInterface()
-        ret = ri.questionInitializeDASD('', '')
-        self.assertEqual(ret, 1)
-
-    #
-    # module function tests
-    #
-
-    def makefstab_test(self):
-        import pyanaconda.rescue
-        INSTPATH = '/tmp'
-        FSTAB = 'rootfs / rootfs rw 0 0'
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.access.return_value = True
-        self.fs.open('/proc/mounts', 'w').write(FSTAB)
-        self.fs.open('%s/etc/fstab' % INSTPATH, 'w')
-
-        ret = pyanaconda.rescue.makeFStab(INSTPATH)
-        self.assertEqual(self.fs['%s/etc/fstab' % INSTPATH], FSTAB)
-
-    def makeresolvconf_1_test(self):
-        import pyanaconda.rescue
-        INSTPATH = '/tmp'
-        RESOLV = "nameserver 10.0.0.1"
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.access.return_value = False
-        pyanaconda.rescue.shutil = mock.Mock()
-
-        pyanaconda.rescue.makeResolvConf(INSTPATH)
-        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
-
-    def makeresolvconf_2_test(self):
-        import pyanaconda.rescue
-        INSTPATH = '/tmp'
-        RESOLV = "nameserver 10.0.0.1"
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.access.return_value = True
-        pyanaconda.rescue.shutil = mock.Mock()
-        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write(RESOLV)
-
-        pyanaconda.rescue.makeResolvConf(INSTPATH)
-        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
-
-    def makeresolvconf_3_test(self):
-        import pyanaconda.rescue
-        INSTPATH = '/tmp'
-        RESOLV = "nameserver 10.0.0.1"
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.access.return_value = True
-        pyanaconda.rescue.shutil = mock.Mock()
-        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write('')
-        self.fs.open('/etc/resolv.conf', 'w').write('')
-
-        pyanaconda.rescue.makeResolvConf(INSTPATH)
-        self.assertFalse(pyanaconda.rescue.shutil.copyfile.called)
-        self.assertEqual(self.fs['%s/etc/resolv.conf' % INSTPATH], '')
-
-    def makeresolvconf_4_test(self):
-        import pyanaconda.rescue
-        INSTPATH = '/tmp'
-        RESOLV = "nameserver 10.0.0.1"
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.access.return_value = True
-        pyanaconda.rescue.shutil = mock.Mock()
-        self.fs.open('%s/etc/resolv.conf' % INSTPATH, 'w').write('')
-        self.fs.open('/etc/resolv.conf', 'w').write(RESOLV)
-
-        pyanaconda.rescue.makeResolvConf(INSTPATH)
-        self.assertTrue(pyanaconda.rescue.shutil.copyfile.called)
-        self.assertEqual(self.fs['%s/etc/resolv.conf' % INSTPATH],
-            'nameserver 10.0.0.1')
-
-    def startnetworking_test(self):
-        import pyanaconda.rescue
-        NETWORK = mock.Mock()
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.startNetworking(NETWORK, '')
-        self.assertEqual(pyanaconda.rescue.os.system.call_args,
-            (('/usr/sbin/ifconfig lo 127.0.0.1',), {}))
-        self.assertTrue(NETWORK.bringUp.called)
-
-    def runshell_1_test(self):
-        import pyanaconda.rescue
-        import sys
-        TMPFILE = '/tmp/abc'
-        MSG = "foo bar"
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.path.exists.return_value = True
-        pyanaconda.rescue.subprocess = mock.Mock()
-        proc = mock.Mock()
-        proc.returncode = 0
-        pyanaconda.rescue.subprocess.Popen.return_value = proc
-
-        stdout = sys.stdout
-        sys.stdout = self.fs.open(TMPFILE, 'w')
-        pyanaconda.rescue.runShell(msg=MSG)
-        sys.stdout.close()
-        sys.stdout = stdout
-
-        self.assertTrue(MSG in self.fs[TMPFILE])
-        self.assertEqual(pyanaconda.rescue.subprocess.Popen.call_args,
-            ((['/usr/bin/firstaidkit-qs'],), {}))
-
-    def runshell_2_test(self):
-        import pyanaconda.rescue
-        import sys
-        TMPFILE = '/tmp/abc'
-        MSG = "foo bar"
-
-        def fake_f(filename, _=""):
-            return filename == "/bin/bash"
-
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.path.exists = fake_f
-        pyanaconda.rescue.iutil = mock.Mock()
-        proc = mock.Mock()
-        proc.returncode = 0
-        pyanaconda.rescue.subprocess.Popen.return_value = proc
-
-        stdout = sys.stdout
-        sys.stdout = self.fs.open(TMPFILE, 'w')
-        pyanaconda.rescue.runShell(msg=MSG)
-        sys.stdout.close()
-        sys.stdout = stdout
-
-        self.assertTrue(MSG in self.fs[TMPFILE])
-        self.assertTrue(pyanaconda.rescue.iutil.execConsole.called)
-
-    def runshell_3_test(self):
-        import pyanaconda.rescue
-        import sys
-        TMPFILE = '/tmp/abc'
-        SCREEN = mock.Mock()
-        pyanaconda.rescue.os = mock.Mock()
-        pyanaconda.rescue.os.path.exists.return_value = True
-        pyanaconda.rescue.subprocess = mock.Mock()
-        proc = mock.Mock()
-        proc.returncode = 0
-        pyanaconda.rescue.subprocess.Popen.return_value = proc
-
-        pyanaconda.rescue.runShell(screen=SCREEN)
-
-        self.assertTrue(SCREEN.suspend.called)
-        self.assertTrue(SCREEN.finish.called)
diff --git a/tests/pyanaconda_test/security_test.py b/tests/pyanaconda_test/security_test.py
deleted file mode 100644
index 33b94c1..0000000
--- a/tests/pyanaconda_test/security_test.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-
-class SecurityTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])
-
-        self.fs = mock.DiskIO()
-
-        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
-        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_test(self):
-        """Simulate writing security (simulate executing lokkit and authconfig)"""
-        import pyanaconda.security
-
-        scrt = pyanaconda.security.Security()
-        pyanaconda.security.ROOT_PATH = "/tmp/security"
-        scrt.write()
-
-        self.assertEqual(pyanaconda.security.iutil.method_calls,
-            [('execWithRedirect',
-                ('/usr/sbin/lokkit', ['--selinux=enforcing']),
-                {'root': '/tmp/security', 'stderr': '/dev/null', 'stdout': '/dev/null'}
-             ),
-             ('resetRpmDb', (), {}),
-             ('execWithRedirect',
-                ('/usr/sbin/authconfig',
-                    ['--update', '--nostart', '--enableshadow', '--passalgo=sha512']
-                ),
-                {'root': '/tmp/security', 'stderr': '/dev/tty5', 'stdout': '/dev/tty5'}
-             )
-            ]
-        )
diff --git a/tests/pyanaconda_test/simpleconfig_test.py b/tests/pyanaconda_test/simpleconfig_test.py
deleted file mode 100644
index 265ed88..0000000
--- a/tests/pyanaconda_test/simpleconfig_test.py
+++ /dev/null
@@ -1,154 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import os
-import sys
-
-class SimpleconfigTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])
-        import pyanaconda.simpleconfig
-
-        # Stuff for IfcfgFile class tests
-        self.DIR = '/tmp/'
-        self.IFACE = 'eth0'
-        self.PATH = "%sifcfg-%s" % (self.DIR, self.IFACE)
-        self.CONTENT = '# Broadcom Corporation NetXtreme BCM5761 Gigabit Ethernet\n'
-        self.CONTENT += 'DEVICE=eth0\n'
-        self.CONTENT += 'HWADDR=00:10:18:61:35:98\n'
-        self.CONTENT += 'ONBOOT=no\n'
-        open(self.PATH, 'w').write(self.CONTENT)
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def uppercase_ascii_string_letters_test(self):
-        """Converting to uppercase (letters)"""
-        import pyanaconda.simpleconfig
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('abcd')
-        self.assertEqual(ret, 'ABCD')
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('aBCD')
-        self.assertEqual(ret, 'ABCD')
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('ABCD')
-        self.assertEqual(ret, 'ABCD')
-
-    def uppercase_ascii_string_numbers_test(self):
-        """Converting to uppercase (numbers)"""
-        import pyanaconda.simpleconfig
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('123')
-        self.assertEqual(ret, '123')
-
-    def uppercase_ascii_string_others_test(self):
-        """Converting to uppercase (special chars)"""
-        import pyanaconda.simpleconfig
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('--')
-        self.assertEqual(ret, '--')
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string(' ')
-        self.assertEqual(ret, ' ')
-        ret = pyanaconda.simpleconfig.uppercase_ASCII_string('')
-        self.assertEqual(ret, '')
-
-    def unquote_test(self):
-        from pyanaconda.simpleconfig import unquote
-        self.assertEqual(unquote("plain string"), "plain string")
-        self.assertEqual(unquote('"double quote"'), "double quote")
-        self.assertEqual(unquote("'single quote'"), "single quote")
-
-    def quote_test(self):
-        from pyanaconda.simpleconfig import quote
-        self.assertEqual(quote("nospaces"), "nospaces")
-        self.assertEqual(quote("plain string"), '"plain string"')
-        self.assertEqual(quote("alwaysquote", always=True), '"alwaysquote"')
-
-    def set_and_get_test(self):
-        """Setting and getting values"""
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.SimpleConfigFile()
-        scf.set(('key1', 'value1'))
-        self.assertEqual(scf.get('key1'), 'value1')
-        scf.set(('KEY2', 'value2'))
-        self.assertEqual(scf.get('key2'), 'value2')
-        scf.set(('KEY3', 'value3'))
-        self.assertEqual(scf.get('KEY3'), 'value3')
-        scf.set(('key4', 'value4'))
-        self.assertEqual(scf.get('KEY4'), 'value4')
-
-    def unset_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.SimpleConfigFile()
-        scf.set(('key1', 'value1'))
-        scf.unset(('key1'))
-        self.assertEqual(scf.get('key1'), '')
-
-    def write_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.SimpleConfigFile()
-        scf.set(('key1', 'value1'))
-        scf.write('/tmp/file')
-        self.assertEqual(open('/tmp/file').read(), 'KEY1=value1\n')
-
-    def read_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.SimpleConfigFile()
-        open('/tmp/file', 'w').write('KEY1="value1"\n')
-        scf.read('/tmp/file')
-        self.assertEqual(scf.get('key1'), 'value1')
-
-    def read_write_test(self):
-        from pyanaconda.simpleconfig import SimpleConfigFile
-        scf = SimpleConfigFile()
-        scf.read(self.PATH)
-        scf.write("/tmp/file")
-        self.assertEqual(open("/tmp/file").read(), self.CONTENT)
-
-    def write_new_keys_test(self):
-        from pyanaconda.simpleconfig import SimpleConfigFile
-        scf = SimpleConfigFile()
-        scf.read(self.PATH)
-        scf.set(("key1", "value1"))
-        scf.write("/tmp/file")
-        self.assertEqual(open("/tmp/file").read(),
-                         self.CONTENT+"KEY1=value1\n")
-
-    def remove_key_test(self):
-        from pyanaconda.simpleconfig import SimpleConfigFile
-        scf = SimpleConfigFile()
-        scf.read(self.PATH)
-        scf.unset("BOOT")
-        scf.write("/tmp/file")
-        scf.reset()
-        scf.read("/tmp/file")
-        self.assertEqual(scf.get("BOOT"), "")
-
-    def ifcfgfile_path_property_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
-        self.assertEqual(scf.path, self.PATH)
-
-    def ifcfgfile_read_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
-        scf.read()
-        self.assertEqual(scf.get('device'), 'eth0')
-        self.assertEqual(scf.get('hwaddr'), '00:10:18:61:35:98')
-        self.assertEqual(scf.get('onboot'), 'no')
-
-    def ifcfgfile_read_and_clear_test(self):
-        import pyanaconda.simpleconfig        
-        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
-        scf.read()
-        scf.clear()
-        self.assertEqual(scf.get('device'), '')
-        self.assertEqual(scf.get('hwaddr'), '')
-        self.assertEqual(scf.get('onboot'), '')
-
-    def ifcfgfile_write_test(self):
-        import pyanaconda.simpleconfig
-        scf = pyanaconda.simpleconfig.IfcfgFile(self.DIR, self.IFACE)
-        scf.set(('device', 'eth0'))
-        scf.set(('hwaddr', '00:11:22:33:44:55'))
-        scf.set(('onboot', 'no'))
-        scf.write()
-        self.assertEqual(open(self.PATH).read(),
-            'DEVICE="eth0"\nHWADDR="00:11:22:33:44:55"\nONBOOT="no"\n')
-
diff --git a/tests/pyanaconda_test/timezone_test.py b/tests/pyanaconda_test/timezone_test.py
deleted file mode 100644
index a53f292..0000000
--- a/tests/pyanaconda_test/timezone_test.py
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-
-ZONE = 'Europe/Prague'
-UTC = 2
-
-class TimeZoneTest(mock.TestCase):
-    def setUp(self):
-        self.setupModules(["_isys", "block", "ConfigParser"])
-
-        self.fs = mock.DiskIO()
-
-        import pyanaconda.timezone
-        pyanaconda.timezone.log = mock.Mock()
-        pyanaconda.timezone.open = self.fs.open
-        pyanaconda.timezone.os.access = mock.Mock(return_value = True)
-        pyanaconda.timezone.shutil.copyfile = mock.Mock()
-        pyanaconda.timezone.os = mock.Mock()
-        pyanaconda.timezone.os.access.return_value = True
-        pyanaconda.timezone.shutil = mock.Mock()
-        #pyanaconda.timezone.shutil.copyfile = mock.Mock()
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def get_timezone_info_test(self):
-        import pyanaconda.timezone
-        tz = pyanaconda.timezone.Timezone()
-        info = tz.getTimezoneInfo()
-        self.assertEqual( (tz.tz, tz.utc), info )
-
-    def set_timezone_info_test(self):
-        import pyanaconda.timezone
-        tz = pyanaconda.timezone.Timezone()
-        tz.setTimezoneInfo(ZONE, UTC)
-        self.assertEqual((ZONE, UTC), (tz.tz, tz.utc))
-
-    def write_test(self):
-        import pyanaconda.timezone
-
-        tz = pyanaconda.timezone.Timezone()
-        tz.tz = ZONE
-        tz.utc = True
-
-        PATH = ''
-        ADJTIME = '0.013782 1279118821 0.000000\n1279118821\nUTC\n'
-        f = self.fs.open('/mnt/sysimage/etc/adjtime', 'w')
-        f.write(ADJTIME)
-        f.close()
-
-        tz.write()
-        self.assertEqual(self.fs['/mnt/sysimage/etc/adjtime'], ADJTIME)
-
-
diff --git a/tests/pyanaconda_test/users_test.py b/tests/pyanaconda_test/users_test.py
deleted file mode 100644
index c457ef7..0000000
--- a/tests/pyanaconda_test/users_test.py
+++ /dev/null
@@ -1,142 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import sys
-
-GIDNUMBER = 'pw_gid'
-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
-        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.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
-
-        GROUP = 'Group'
-        GID = 100
-        group_dict = {  "name" : GROUP,
-                        "gid" : GID,
-                        "root" : ""
-                    }
-
-        usr = pyanaconda.users.Users(self.anaconda)
-        self.assertTrue(usr.createGroup(GROUP, **group_dict))
-
-        methods = pyanaconda.users.libuser.admin().method_calls[:]
-        try:
-            if methods[2][0] == 'addGroup':
-                methods.pop()
-        except:
-            pass
-
-        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
-
-        USER = 'TestUser'
-        PASS = 'abcde'
-        user_dict = {   "name" : USER,
-                        "password" : PASS,
-                        "groups" : [],
-                        "homedir" : "",
-                        "isCrypted" : False,
-                        "shell" : "",
-                        "uid" : None,
-                        "root" : ""
-                    }
-
-        usr = pyanaconda.users.Users(self.anaconda)
-        self.assertTrue(usr.createUser(USER, **user_dict))
-
-        self.assertTrue(pyanaconda.users.iutil.mkdirChain.called)
-        methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
-
-        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', (HOMEDIRECTORY, '/home/%s' % USER), {})]
-        )
-
-        self.assertEqual(pyanaconda.users.libuser.admin().initGroup().method_calls,
-            [('get', (GIDNUMBER,), {})])
-
-    def check_user_exists_test(self):
-        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,), {})])
-
-    def get_pass_algo_md5_test(self):
-        import pyanaconda.users
-        usr = pyanaconda.users.Users(self.anaconda)
-        self.assertEqual(usr.getPassAlgo(), None)
-
-    def set_user_password_test(self):
-        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,
-            ['lookupUserByName', 'setpassUser', 'modifyUser'])
-
-    def set_root_password_test(self):
-        import pyanaconda.users
-
-        usr = pyanaconda.users.Users(self.anaconda)
-        usr.setRootPassword()
-        methods = [x[0] for x in pyanaconda.users.libuser.admin().method_calls]
-        self.assertEqual(methods,
-            ['lookupUserByName', 'setpassUser', 'modifyUser'])
diff --git a/tests/pyanaconda_test/vnc_test.py b/tests/pyanaconda_test/vnc_test.py
deleted file mode 100644
index 80cc527..0000000
--- a/tests/pyanaconda_test/vnc_test.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#!/usr/bin/python
-
-import mock
-import os
-
-class VncTest(mock.TestCase):
-
-    def setUp(self):
-        self.setupModules(["_isys", "block", "logging", "ConfigParser"])
-        self.fs = mock.DiskIO()
-
-        self.anaconda = mock.Mock()
-        self.anaconda.ksdata.vnc.password = ''
-
-        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.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'
-        self.PASS = ''
-        self.LOG_FILE = '/tmp/vnc.log'
-        self.PW_FILE = '/tmp/vncpassword'
-        self.VNCCONNECTHOST = 'host'
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def set_vnc_password_1_test(self):
-        import pyanaconda.vnc
-        server = pyanaconda.vnc.VncServer()
-        server.anaconda = self.anaconda
-        pyanaconda.vnc.iutil = mock.Mock()
-        pyanaconda.vnc.os.pipe.return_value = (1, 2)
-
-        server.setVNCPassword()
-        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()
-        pyanaconda.vnc.network.Network().netdevices = [dev]
-        pyanaconda.vnc.network.getActiveNetDevs.return_value = [0]
-        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 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.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.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()
-        pyanaconda.vnc.VncServer.setVNCPassword = mock.Mock()
-        pyanaconda.vnc.VncServer.VNCListen = mock.Mock()
-        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)
diff --git a/tests/pyanaconda_tests/localization_test.py b/tests/pyanaconda_tests/localization_test.py
new file mode 100644
index 0000000..2cdcce8
--- /dev/null
+++ b/tests/pyanaconda_tests/localization_test.py
@@ -0,0 +1,109 @@
+#
+# Copyright (C) 2013  Red Hat, Inc.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions of
+# the GNU General Public License v.2, or (at your option) any later version.
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY expressed or implied, including the implied warranties of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.  You should have received a copy of the
+# GNU General Public License along with this program; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
+# source code or documentation are not subject to the GNU General Public
+# License and may only be used or replicated with the express permission of
+# Red Hat, Inc.
+#
+# Red Hat Author(s): Vratislav Podzimek <vpodzime at redhat.com>
+#
+
+from pyanaconda import localization
+import unittest
+
+class ParsingTests(unittest.TestCase):
+    def invalid_langcodes_test(self):
+        """Should return None for invalid langcodes."""
+
+        # nonsense
+        parts = localization.parse_langcode("*_&!")
+        self.assertIsNone(parts)
+
+        # no language
+        parts = localization.parse_langcode("_CZ")
+        self.assertIsNone(parts)
+
+    def parsing_test(self):
+        """Should correctly parse valid langcodes."""
+
+        parts = localization.parse_langcode("cs")
+        self.assertIn("language", parts)
+        self.assertEqual(parts["language"], "cs")
+
+        parts = localization.parse_langcode("cs_CZ")
+        self.assertIn("language", parts)
+        self.assertIn("territory", parts)
+        self.assertEqual(parts["language"], "cs")
+        self.assertEqual(parts["territory"], "CZ")
+
+        parts = localization.parse_langcode("cs_CZ.UTF-8")
+        self.assertIn("language", parts)
+        self.assertIn("territory", parts)
+        self.assertIn("encoding", parts)
+        self.assertEqual(parts["language"], "cs")
+        self.assertEqual(parts["territory"], "CZ")
+        self.assertEqual(parts["encoding"], "UTF-8")
+
+        parts = localization.parse_langcode("cs_CZ.UTF-8 at latin")
+        self.assertIn("language", parts)
+        self.assertIn("territory", parts)
+        self.assertIn("encoding", parts)
+        self.assertIn("script", parts)
+        self.assertEqual(parts["language"], "cs")
+        self.assertEqual(parts["territory"], "CZ")
+        self.assertEqual(parts["encoding"], "UTF-8")
+        self.assertEqual(parts["script"], "latin")
+
+        parts = localization.parse_langcode("cs.UTF-8 at latin")
+        self.assertIn("language", parts)
+        self.assertIn("encoding", parts)
+        self.assertIn("script", parts)
+        self.assertEqual(parts["language"], "cs")
+        self.assertEqual(parts["encoding"], "UTF-8")
+        self.assertEqual(parts["script"], "latin")
+
+        parts = localization.parse_langcode("cs_CZ at latin")
+        self.assertIn("language", parts)
+        self.assertIn("territory", parts)
+        self.assertIn("script", parts)
+        self.assertEqual(parts["language"], "cs")
+        self.assertEqual(parts["territory"], "CZ")
+        self.assertEqual(parts["script"], "latin")
+
+class UpcaseFirstLetterTests(unittest.TestCase):
+    def upcase_first_letter_test(self):
+        """Upcasing first letter should work as expected."""
+
+        # no change
+        self.assertEqual(localization._upcase_first_letter("Czech RePuBliC"),
+                         "Czech RePuBliC")
+
+        # simple case
+        self.assertEqual(localization._upcase_first_letter("czech"), "Czech")
+
+        # first letter only
+        self.assertEqual(localization._upcase_first_letter("czech republic"),
+                         "Czech republic")
+
+        # no lowercase
+        self.assertEqual(localization._upcase_first_letter("czech Republic"),
+                         "Czech Republic")
+
+class ExpandLangsTest(unittest.TestCase):
+    def expand_langs_test(self):
+        """expand_langs should return every valid combination."""
+
+        expected_result = ["fr", "fr_FR", "fr_FR.UTF-8 at euro", "fr.UTF-8 at euro",
+                           "fr_FR at euro", "fr_FR.UTF-8", "fr at euro", "fr.UTF-8"]
+        self.assertListEqual(localization.expand_langs("fr_FR.UTF-8 at euro"),
+                             expected_result)
diff --git a/tests/pyanaconda_tests/timezone_test.py b/tests/pyanaconda_tests/timezone_test.py
new file mode 100644
index 0000000..c277bd0
--- /dev/null
+++ b/tests/pyanaconda_tests/timezone_test.py
@@ -0,0 +1,73 @@
+#
+# Copyright (C) 2013  Red Hat, Inc.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions of
+# the GNU General Public License v.2, or (at your option) any later version.
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY expressed or implied, including the implied warranties of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.  You should have received a copy of the
+# GNU General Public License along with this program; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
+# source code or documentation are not subject to the GNU General Public
+# License and may only be used or replicated with the express permission of
+# Red Hat, Inc.
+#
+# Red Hat Author(s): Vratislav Podzimek <vpodzime at redhat.com>
+#
+
+from pyanaconda import timezone
+import unittest
+import langtable
+import mock
+
+class TimezonesListings(unittest.TestCase):
+    def string_timezones_test(self):
+        """Check if returned timezones are plain strings, not unicode objects."""
+        for (region, zones) in timezone.get_all_regions_and_timezones().iteritems():
+            self.assertIsInstance(region, str)
+
+            for zone in zones:
+                self.assertIsInstance(zone, str)
+
+    def all_timezones_valid_test(self):
+        """Check if all returned timezones are considered valid timezones."""
+
+        for (region, zones) in timezone.get_all_regions_and_timezones().iteritems():
+            for zone in zones:
+                self.assertTrue(timezone.is_valid_timezone(region + "/" + zone))
+
+class TerritoryTimezones(unittest.TestCase):
+    def string_valid_territory_zone_test(self):
+        """Check if the returned value is string for a valid territory."""
+
+        zone = timezone.get_preferred_timezone("CZ")
+        self.assertIsInstance(zone, str)
+
+    def invalid_territory_zones_test(self):
+        """Check if None is return for an invalid territory."""
+
+        self.assertIsNone(timezone.get_preferred_timezone("nonexistent"))
+
+class s390HWclock(unittest.TestCase):
+    def setUp(self):
+        self.arch_mock = mock.Mock()
+        self.arch_mock.isS390.return_value = True
+        self.iutil_mock = mock.Mock()
+
+        timezone.save_hw_clock.func_globals["arch"] = self.arch_mock
+        timezone.save_hw_clock.func_globals["iutil"] = self.iutil_mock
+
+    def s390_save_hw_clock_test(self):
+        """Check that save_hw_clock does nothing on s390."""
+
+        timezone.save_hw_clock(mock.Mock())
+        self.assertFalse(self.iutil_mock.execWithRedirect.called)
+
+    def s390_time_initalize_test(self):
+        """Check that time_initialize doesn't call hwclock on s390."""
+
+        timezone.time_initialize(mock.Mock(), mock.Mock(), mock.Mock())
+        self.assertFalse(self.iutil_mock.execWithRedirect.called)
diff --git a/tests/pylint/Makefile.am b/tests/pylint/Makefile.am
deleted file mode 100644
index f934cf5..0000000
--- a/tests/pylint/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-# tests/kickstart/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Chris Lumens <clumens at redhat.com>
-
-EXTRA_DIST = *pylint*
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/tests/pylint/pylint-false-positives b/tests/pylint/pylint-false-positives
deleted file mode 100644
index 97f566c..0000000
--- a/tests/pylint/pylint-false-positives
+++ /dev/null
@@ -1,34 +0,0 @@
-^F0002:[ 0-9]*: <type 'exceptions.RuntimeError'>: could not open display$
-^F0401:[ 0-9]*: Unable to import 'gtk.gdk'$
-^F0401:[ 0-9]*: Unable to import 'repomd.mdErrors'$
-^F0401:[ 0-9]*: Unable to import 'volume_key'$
-^E0601:[ 0-9]*:VolumeGroupEditor\.editLogicalVolume\.<lambda>: Using variable 'maintable' before assignment$
-^W0122:[ 0-9]*:InstallInterface\.run: Use of the exec statement$
-^E0602:[ 0-9]*:InstallInterface\.run: Undefined variable 'nextWin'$
-^E0602:[ 0-9]*:sparcBootloaderInfo\.writeSilo: Undefined variable 'butil'$
-^E0611:[ 0-9]*: No name '_isys' in module 'pyanaconda'$
-^E0611:[ 0-9]*:.*: No name '_isys' in module 'pyanaconda'$
-^E1101:[ 0-9]*:.*: Class 'vbox' has no 'pack_start' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'get_model' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'get_column' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'set_expander_column' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'append_row' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'store' member$
-^E1101:[ 0-9]*:.*: Instance of 'WideCheckList' has no 'set_size_request' member$
-^E1101:[ 0-9]*:.*: Instance of '.*' has no 'anaconda' member$
-^E1101:[ 0-9]*:.*: Instance of 'AnacondaKSHandler' has no 'commands' member$
-^E1101:[ 0-9]*:AnacondaTZMap\.selectionChanged: Instance of 'Enum' has no 'ENTRY' member$
-^E1101:[ 0-9]*:DeviceAction\..*: Instance of 'DeviceAction' has no 'dir' member$
-^E1101:[ 0-9]*:VolumeGroupEditor\.editLogicalVolume: Class 'format' has no 'mountable' member$
-^E1101:[ 0-9]*:randomIname: Module 'hashlib' has no 'md5' member$
-^E1101:[ 0-9]*:rpm.*: Instance of 'TransactionSet' has no 'dbMatch' member$
-^E1101:[ 0-9]*:EntryWindow.__init__: Class 'child' has no 'pack_start' member$
-^E1101:[ 0-9]*:.*: Instance of 'dict' has no 'Get' member$
-^E1101:[ 0-9]*:FilteredCallbacks\..*set: Instance of 'FilteredCallbacks' has no 'notebook' member$
-^E1101:[ 0-9]*:Anaconda\.backend: Instance of 'DefaultInstall' has no 'getBackend' member$
-^W0404:[ 0-9]*:runRescue: Reimport 'runPostScripts' \(imported line [0-9]*\)$
-# Note this will become a real issue when we start supporting multiple netdevs
-^W0631:[ 0-9]*:Network.write: Using possibly undefined loop variable 'dev'$
-# Also filter out the stupid pyblock not running as root message
-^dm.c: [ 0-9]*: not running as root returning empty list$
-Note this last line must never end with a newline
\ No newline at end of file
diff --git a/tests/pylint/runpylint.sh b/tests/pylint/runpylint.sh
deleted file mode 100755
index afd95fc..0000000
--- a/tests/pylint/runpylint.sh
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/bin/bash
-
-# This script will check anaconda for any pylint warning and errors using a set
-# of options minimizing false positives, in combination with filtering of any
-# warning regularexpressions listed in pylint-false-positives.
-# 
-# If any warnings our found they will be stored in pylint-log and printed
-# to stdout and this script will exit with a status of 1, if no (non filtered)
-# warnings are found it exits with a status of 0
-
-FALSE_POSITIVES=tests/pylint/pylint-false-positives
-
-# W0107 - Unnecessary pass statement
-# W0108 - Lambda may not be necessary
-# W0212 - Access to a protected member %s of a client class
-# W0311 - Bad indentation. Found %s %s, expected %s
-# W0312 - Found indentation with %ss instead of %ss
-# W0402 - Uses of a deprecated module %r
-# W0611 - Unused import %s
-# W0612 - Unused variable %r
-# W0710 - Exception doesn't inherit from standard "Exception" class
-NON_STRICT_OPTIONS="--disable=W0107,W0108,W0212,W0311,W0312,W0402,W0611,W0612,W0710"
-
-# E1103 - %s %r has no %r member (but some types could not be inferred)
-DISABLED_ERR_OPTIONS="--disable=E1103"
-
-# W0102 - Dangerous default value %s as argument
-# W0141 - Used builtin function %r
-# W0142 - Used * or ** magic
-# W0201 - Attribute %r defined outside __init__
-# W0221 - Arguments number differs from %s method
-# W0223 - Method %r is abstract in class %r but is not overridden
-# W0231 - __init__ method from base class %r is not called
-# W0232 - Class has no __init__ method
-# W0233 - __init__ method from a non direct base class %r is called
-# W0401 - Wildcard import %s
-# W0403 - Relative import %r, should be %r
-# W0404 - Reimport %r (imported line %s)
-# W0511 - Used when a warning note as FIXME or XXX is detected.
-# W0602 - Using global for %r but no assignment is done
-# W0603 - Using the global statement
-# W0604 - Using the global statement at the module level
-# W0613 - Unused argument %r
-# W0614 - Unused import %s from wildcard import
-# W0621 - Redefining name %r from outer scope (line %s)
-# W0622 - Redefining built-in %r
-# W0702 - No exception type(s) specified
-# W0703 - Catch "Exception"
-# W1001 - Use of "property" on an old style class
-DISABLED_WARN_OPTIONS="--disable=W0102,W0141,W0142,W0201,W0221,W0223,W0231,W0232 \
-                       --disable=W0233,W0401,W0403,W0404,W0511,W0602,W0603,W0604 \
-                       --disable=W0613,W0614,W0621,W0622,W0702,W0703,W1001"
-
-usage () {
-  echo "usage: `basename $0` [--strict] [--help]"
-  exit $1
-}
-
-while [ $# -gt 0 ]; do
-  case $1 in
-    --strict)
-      NON_STRICT_OPTIONS=
-      ;;
-    --help)
-      usage 0
-      ;;
-    *)
-      echo "Error unknown option: $1"
-      usage 1
-  esac
-  shift
-done
-
-if [ "`tail -c 1 $FALSE_POSITIVES`" == "`echo`" ]; then
-  echo "Error $FALSE_POSITIVES ends with an enter."
-  echo "Error the last line of $FALSE_POSITIVES should never have an enter!"
-  exit 1
-fi
-
-# run pylint one file / module at a time, otherwise it sometimes gets
-# confused
-> pylint-log
-for i in $(find pyanaconda -type f -name '*py'); do
-  pylint --init-hook='import sys; \
-      sys.path.insert(1, "pyanaconda/isys/.libs"); \
-      sys.path.insert(2, "pyanaconda/isys"); \
-      sys.path.insert(3, "pyanaconda"); \
-      sys.path.insert(4, "pyanaconda/.libs")' \
-    -i y -r n --disable=C,R --rcfile=/dev/null \
-    $DISABLED_WARN_OPTIONS \
-    $DISABLED_ERR_OPTIONS \
-    $NON_STRICT_OPTIONS $i | \
-    egrep -v "`cat $FALSE_POSITIVES | tr '\n' '|'`" > pylint-tmp-log
-  if grep -q -v '************* Module ' pylint-tmp-log; then
-    cat pylint-tmp-log >> pylint-log
-  fi
-done
-rm pylint-tmp-log
-
-if [ -s pylint-log ]; then
-  echo "pylint reports the following issues:"
-  cat pylint-log
-  exit 1
-fi
-
-rm pylint-log
-
-exit 0
diff --git a/tests/regex/Makefile.am b/tests/regex/Makefile.am
deleted file mode 100644
index af1bd58..0000000
--- a/tests/regex/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-# tests/regex/Makefile.am for anaconda
-#
-# Copyright (C) 2010  Red Hat, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published
-# by the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Author: Brian C. Lane <bcl at redhat.com>
-
-EXTRA_DIST = *.py
-
-MAINTAINERCLEANFILES = Makefile.in
diff --git a/tests/regex/__init__.py b/tests/regex/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/regex/proxy_test.py b/tests/regex/proxy_test.py
deleted file mode 100755
index 8d5596c..0000000
--- a/tests/regex/proxy_test.py
+++ /dev/null
@@ -1,112 +0,0 @@
-#!/usr/bin/python
-import unittest
-import re
-import traceback
-
-
-class ProxyRegexTestCase(unittest.TestCase):
-    def testProxy(self):
-        """
-        Run a list of possible proxy= values through the regex and check for
-        correct results.
-
-        tests are in the form of: (proxy string, match.groups() tuple)
-        """
-        tests = [ ( "proxy.host",
-                      (None, None, None, None, 'proxy.host', None, None) ),
-
-                  ( "proxy.host:3128",
-                      (None, None, None, None, 'proxy.host', ':3128', None) ),
-
-                  ( "user:password at proxy.host",
-                      (None, 'user:password@', 'user', ':password', 'proxy.host', None, None) ),
-
-                  ( "user at proxy.host",
-                      (None, 'user@', 'user', None, 'proxy.host', None, None) ),
-
-                  ( "user:password at proxy.host:3128",
-                      (None, 'user:password@', 'user', ':password', 'proxy.host', ':3128', None) ),
-
-                  ( "user at proxy.host:3128",
-                      (None, 'user@', 'user', None, 'proxy.host', ':3128', None) ),
-
-                  ( "proxy.host/blah/blah",
-                      (None, None, None, None, 'proxy.host', None, '/blah/blah') ),
-
-                  ( "proxy.host:3128/blah/blah",
-                      (None, None, None, None, 'proxy.host', ':3128', '/blah/blah') ),
-
-                  ( "user:password at proxy.host/blah/blah",
-                      (None, 'user:password@', 'user', ':password', 'proxy.host', None, '/blah/blah') ),
-
-                  ( "user at proxy.host/blah/blah",
-                      (None, 'user@', 'user', None, 'proxy.host', None, '/blah/blah') ),
-
-                  ( "user:password at proxy.host:3128/blah/blah",
-                      (None, 'user:password@', 'user', ':password', 'proxy.host', ':3128', "/blah/blah") ),
-
-                  ( "user at proxy.host:3128/blah/blah",
-                      (None, 'user@', 'user', None, 'proxy.host', ':3128', "/blah/blah") ),
-
-
-
-                  ( "http://proxy.host",
-                      ('http://', None, None, None, 'proxy.host', None, None) ),
-
-                  ( "http://proxy.host:3128",
-                      ('http://', None, None, None, 'proxy.host', ':3128', None) ),
-
-                  ( "http://user:password@proxy.host",
-                      ('http://', 'user:password@', 'user', ':password', 'proxy.host', None, None) ),
-
-                  ( "http://user@proxy.host",
-                      ('http://', 'user@', 'user', None, 'proxy.host', None, None) ),
-
-                  ( "http://user:password@proxy.host:3128",
-                      ('http://', 'user:password@', 'user', ':password', 'proxy.host', ':3128', None) ),
-
-                  ( "http://user@proxy.host:3128",
-                      ('http://', 'user@', 'user', None, 'proxy.host', ':3128', None) ),
-
-                  ( "http://proxy.host/blah/blah",
-                      ('http://', None, None, None, 'proxy.host', None, '/blah/blah') ),
-
-                  ( "http://proxy.host:3128/blah/blah",
-                      ('http://', None, None, None, 'proxy.host', ':3128', '/blah/blah') ),
-
-                  ( "http://user:password@proxy.host/blah/blah",
-                      ("http://", 'user:password@', 'user', ':password', 'proxy.host', None, '/blah/blah') ),
-
-                  ( "http://user@proxy.host/blah/blah",
-                      ("http://", 'user@', 'user', None, 'proxy.host', None, '/blah/blah') ),
-
-                  ( "http://user:password@proxy.host:3128/blah/blah",
-                      ("http://", 'user:password@', 'user', ':password', 'proxy.host', ':3128', '/blah/blah') ),
-
-                  ( "http://user@proxy.host:3128/blah/blah",
-                      ("http://", 'user@', 'user', None, 'proxy.host', ':3128', '/blah/blah') ),
-
-                ]
-
-
-        # This is from yumupdate.py and needs to be updated when it changes
-        pattern = re.compile("([A-Za-z]+://)?(([A-Za-z0-9]+)(:[^:@]+)?@)?([^:/]+)(:[0-9]+)?(/.*)?")
-
-        got_error = False
-        for proxy, result in tests:
-            try:
-                self.assertEqual(pattern.match(proxy).groups(), result)
-            except AssertionError as error:
-                got_error = True
-                print error
-
-        if got_error:
-            self.fail()
-
-def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(ProxyRegexTestCase)
-
-
-if __name__ == "__main__":
-    unittest.main()
-
-- 
1.7.11.7



More information about the anaconda-patches mailing list