From d9d4391b211c0a13cbfeadc9fa63e5bdeba9d2f6 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 4 Sep 2012 09:52:57 -0400 Subject: reorganized testsuite to allow tests on stuff outside of src --- testsuite/Testsrc/Testlib/TestOptions.py | 238 +++++++++++++++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100644 testsuite/Testsrc/Testlib/TestOptions.py (limited to 'testsuite/Testsrc/Testlib/TestOptions.py') diff --git a/testsuite/Testsrc/Testlib/TestOptions.py b/testsuite/Testsrc/Testlib/TestOptions.py new file mode 100644 index 000000000..e20a320b1 --- /dev/null +++ b/testsuite/Testsrc/Testlib/TestOptions.py @@ -0,0 +1,238 @@ +import os +import sys +from mock import Mock, MagicMock, patch +from Bcfg2.Options import * +from Bcfg2.Compat import ConfigParser + +# add all parent testsuite directories to sys.path to allow (most) +# relative imports in python 2.4 +path = os.path.dirname(__file__) +while path != '/': + if os.path.basename(path).lower().startswith("test"): + sys.path.append(path) + if os.path.basename(path) == "testsuite": + break + path = os.path.dirname(path) +from common import XI_NAMESPACE, XI, inPy3k, call, builtins, u, can_skip, \ + skip, skipIf, skipUnless, Bcfg2TestCase, DBModelTestCase, syncdb, \ + patchIf, datastore + +class TestDefaultConfigParser(Bcfg2TestCase): + @patch("%s.ConfigParser.get" % ConfigParser.__name__) + def test_get(self, mock_get): + dcp = DefaultConfigParser() + mock_get.return_value = "foo" + self.assertEqual(dcp.get("section", "option"), "foo") + mock_get.assert_called_with(dcp, "section", "option") + + mock_get.reset_mock() + self.assertEqual(dcp.get("section", "option", + default="bar", other="test"), "foo") + mock_get.assert_called_with(dcp, "section", "option", other="test") + + for etype, err in [(ConfigParser.NoOptionError, + ConfigParser.NoOptionError(None, None)), + (ConfigParser.NoSectionError, + ConfigParser.NoSectionError(None))]: + mock_get.side_effect = err + mock_get.reset_mock() + self.assertEqual(dcp.get("section", "option", default="bar"), "bar") + mock_get.assert_called_with(dcp, "section", "option") + + mock_get.reset_mock() + self.assertRaises(etype, dcp.get, "section", "option") + mock_get.assert_called_with(dcp, "section", "option") + + @patch("%s.ConfigParser.getboolean" % ConfigParser.__name__) + def test_getboolean(self, mock_getboolean): + dcp = DefaultConfigParser() + mock_getboolean.return_value = True + self.assertEqual(dcp.getboolean("section", "option"), True) + mock_getboolean.assert_called_with(dcp, "section", "option") + + mock_getboolean.reset_mock() + self.assertEqual(dcp.getboolean("section", "option", + default=False, other="test"), True) + mock_getboolean.assert_called_with(dcp, "section", "option", + other="test") + + for etype, err in [(ConfigParser.NoOptionError, + ConfigParser.NoOptionError(None, None)), + (ConfigParser.NoSectionError, + ConfigParser.NoSectionError(None))]: + mock_getboolean.side_effect = err + mock_getboolean.reset_mock() + self.assertEqual(dcp.getboolean("section", "option", default=False), + False) + mock_getboolean.assert_called_with(dcp, "section", "option") + + mock_getboolean.reset_mock() + self.assertRaises(etype, dcp.getboolean, "section", "option") + mock_getboolean.assert_called_with(dcp, "section", "option") + + +class TestOption(Bcfg2TestCase): + def test__init(self): + self.assertRaises(OptionFailure, + Option, + 'foo', False, cmd='f') + self.assertRaises(OptionFailure, + Option, + 'foo', False, cmd='--f') + self.assertRaises(OptionFailure, + Option, + 'foo', False, cmd='-foo') + self.assertRaises(OptionFailure, + Option, + 'foo', False, cmd='-foo', long_arg=True) + opt = Option('foo', False) + self.assertTrue(opt.boolean) + opt = Option('foo', False, odesc='') + self.assertFalse(opt.boolean) + opt = Option('foo', False, cook=get_bool) + self.assertFalse(opt.boolean) + opt = Option('foo', "foo") + self.assertFalse(opt.boolean) + + def test_get_cooked_value(self): + opt = Option('foo', False) + opt.boolean = True + self.assertTrue(opt.get_cooked_value("anything")) + + opt = Option('foo', 'foo') + opt.boolean = False + opt.cook = False + self.assertEqual("foo", opt.get_cooked_value("foo")) + + opt = Option('foo', 'foo') + opt.boolean = False + opt.cook = Mock() + self.assertEqual(opt.cook.return_value, opt.get_cooked_value("foo")) + opt.cook.assert_called_with("foo") + + def test_buildHelpMessage(self): + opt = Option('foo', False) + self.assertEqual(opt.buildHelpMessage(), '') + + opt = Option('foo', False, '-f') + self.assertEqual(opt.buildHelpMessage().split(), + ["-f", "foo"]) + + opt = Option('foo', False, cmd="--foo", long_arg=True) + self.assertEqual(opt.buildHelpMessage().split(), + ["--foo", "foo"]) + + opt = Option('foo', False, cmd="-f", odesc='') + self.assertEqual(opt.buildHelpMessage().split(), + ["-f", "", "foo"]) + + opt = Option('foo', False, cmd="--foo", long_arg=True, odesc='') + self.assertEqual(opt.buildHelpMessage().split(), + ["--foo=", "foo"]) + + def test_buildGetopt(self): + opt = Option('foo', False) + self.assertEqual(opt.buildGetopt(), '') + + opt = Option('foo', False, '-f') + self.assertEqual(opt.buildGetopt(), "f") + + opt = Option('foo', False, cmd="--foo", long_arg=True) + self.assertEqual(opt.buildGetopt(), '') + + opt = Option('foo', False, cmd="-f", odesc='') + self.assertEqual(opt.buildGetopt(), 'f:') + + opt = Option('foo', False, cmd="--foo", long_arg=True, odesc='') + self.assertEqual(opt.buildGetopt(), '') + + def test_buildLongGetopt(self): + opt = Option('foo', False, cmd="--foo", long_arg=True) + self.assertEqual(opt.buildLongGetopt(), 'foo') + + opt = Option('foo', False, cmd="--foo", long_arg=True, odesc='') + self.assertEqual(opt.buildLongGetopt(), 'foo=') + + def test_parse(self): + cf = ('communication', 'password') + o = Option('foo', default='test4', cmd='-F', env='TEST2', + odesc='bar', cf=cf) + o.parse([], ['-F', 'test']) + self.assertEqual(o.value, 'test') + o.parse([('-F', 'test2')], []) + self.assertEqual(o.value, 'test2') + + os.environ['TEST2'] = 'test3' + o.parse([], []) + self.assertEqual(o.value, 'test3') + del os.environ['TEST2'] + + cfp = DefaultConfigParser() + cfp.get = Mock() + cfp.get.return_value = 'test5' + o.parse([], [], configparser=cfp) + cfp.get.assert_any_call(*cf) + self.assertEqual(o.value, 'test5') + + o.cf = False + o.parse([], []) + assert o.value == 'test4' + + +class TestOptionSet(Bcfg2TestCase): + def test_buildGetopt(self): + opts = [('foo', Option('foo', 'test1', cmd='-G')), + ('bar', Option('foo', 'test2')), + ('baz', Option('foo', 'test1', cmd='-H', + odesc='1'))] + oset = OptionSet(opts) + res = oset.buildGetopt() + self.assertIn('H:', res) + self.assertIn('G', res) + self.assertEqual(len(res), 3) + + def test_buildLongGetopt(self): + opts = [('foo', Option('foo', 'test1', cmd='-G')), + ('bar', Option('foo', 'test2')), + ('baz', Option('foo', 'test1', cmd='--H', + odesc='1', long_arg=True))] + oset = OptionSet(opts) + res = oset.buildLongGetopt() + self.assertIn('H=', res) + self.assertEqual(len(res), 1) + + def test_parse(self): + opts = [('foo', Option('foo', 'test1', cmd='-G')), + ('bar', Option('foo', 'test2')), + ('baz', Option('foo', 'test1', cmd='-H', + odesc='1'))] + oset = OptionSet(opts) + self.assertRaises(SystemExit, + oset.parse, + ['-G', '-H']) + oset2 = OptionSet(opts) + self.assertRaises(SystemExit, + oset2.parse, + ['-h']) + oset3 = OptionSet(opts) + oset3.parse(['-G']) + self.assertTrue(oset3['foo']) + + +class TestOptionParser(Bcfg2TestCase): + def test__init(self): + opts = [('foo', Option('foo', 'test1', cmd='-h')), + ('bar', Option('foo', 'test2')), + ('baz', Option('foo', 'test1', cmd='-H', + odesc='1'))] + oset1 = OptionParser(opts) + self.assertEqual(oset1.cfile, + DEFAULT_CONFIG_LOCATION) + sys.argv = ['foo', '-C', '/usr/local/etc/bcfg2.conf'] + oset2 = OptionParser(opts) + self.assertEqual(oset2.cfile, + '/usr/local/etc/bcfg2.conf') + sys.argv = [] + oset3 = OptionParser(opts) + self.assertEqual(oset3.cfile, + DEFAULT_CONFIG_LOCATION) -- cgit v1.2.3-1-g7c22