[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