Merge branch 'config-unit-tests' of git://github.com/elmirjagudin/bui…

…ldbot

master/buildbot/config.py

@@ -166,7 +166,6 @@ def loadConfig(cls, basedir, filename):
             error("Configuration file %r does not define 'BuildmasterConfig'"
                     % (filename,),
             )
-            raise errors
 
         config_dict = localDict['BuildmasterConfig']
 

master/buildbot/test/unit/test_config.py

@@ -19,11 +19,12 @@
 import os
 import textwrap
 import mock
+import __builtin__
 from zope.interface import implements
 from twisted.trial import unittest
 from twisted.application import service
 from twisted.internet import defer
-from buildbot import config, buildslave, interfaces, revlinks
+from buildbot import config, buildslave, interfaces, revlinks, locks
 from buildbot.process import properties, factory
 from buildbot.test.util import dirs, compat
 from buildbot.test.util.config import ConfigErrorsMixin
@@ -99,6 +100,20 @@ def test_error_no_raise(self):
         config.error("message")
         self.assertEqual(e.errors, ["message"])
 
+    def test_str(self):
+        ex = config.ConfigErrors()
+        self.assertEqual(str(ex), "")
+
+        ex = config.ConfigErrors(["a"])
+        self.assertEqual(str(ex), "a")
+
+        ex = config.ConfigErrors(["a", "b"])
+        self.assertEqual(str(ex), "a\nb")
+
+        ex = config.ConfigErrors(["a"])
+        ex.addError('c')
+        self.assertEqual(str(ex), "a\nc")
+
 
 class MasterConfig(ConfigErrorsMixin, dirs.DirsMixin, unittest.TestCase):
 
@@ -188,6 +203,26 @@ def test_loadConfig_missing_basedir(self):
             lambda : config.MasterConfig.loadConfig(
                 os.path.join(self.basedir, 'NO'), 'test.cfg'))
 
+    def test_loadConfig_open_error(self):
+        """
+        Check that loadConfig() raises correct ConfigError exception in cases
+        when configure file is found, but we fail to open it.
+        """
+
+        def raise_IOError(*args):
+            raise IOError("error_msg")
+
+        self.install_config_file('#dummy')
+
+        # override build-in open() function to always rise IOError
+        self.patch(__builtin__, "open", raise_IOError)
+
+        # check that we got the expected ConfigError exception
+        self.assertRaisesConfigError(
+            re.compile("unable to open configuration file .*: error_msg"),
+            lambda : config.MasterConfig.loadConfig(
+                self.basedir, self.filename))
+
     @compat.usesFlushLoggedErrors
     def test_loadConfig_parse_error(self):
         self.install_config_file('def x:\nbar')
@@ -366,6 +401,18 @@ def test_load_global_logCompressionMethod_invalid(self):
                 dict(logCompressionMethod='foo'))
         self.assertConfigError(self.errors, "must be 'bz2' or 'gz'")
 
+    def test_load_global_codebaseGenerator(self):
+        func = lambda _: "dummy"
+        self.do_test_load_global(dict(codebaseGenerator=func),
+                                 codebaseGenerator=func)
+
+    def test_load_global_codebaseGenerator_invalid(self):
+        self.cfg.load_global(self.filename,
+                dict(codebaseGenerator='dummy'))
+        self.assertConfigError(self.errors,
+                "codebaseGenerator must be a callable "
+                "accepting a dict and returning a str")
+
     def test_load_global_logMaxSize(self):
         self.do_test_load_global(dict(logMaxSize=123), logMaxSize=123)
 
@@ -663,6 +710,13 @@ def test_load_change_sources_list(self):
                 dict(change_source=[chsrc]))
         self.assertResults(change_sources=[chsrc])
 
+    def test_load_status_not_list(self):
+        self.cfg.load_status(self.filename, dict(status="not-list"))
+        self.assertConfigError(self.errors, "must be a list of")
+
+    def test_load_status_not_status_rec(self):
+        self.cfg.load_status(self.filename, dict(status=['fo']))
+        self.assertConfigError(self.errors, "must be a list of")
 
     def test_load_user_managers_defaults(self):
         self.cfg.load_user_managers(self.filename, {})
@@ -704,7 +758,24 @@ def setup_basic_attrs(self):
         self.cfg.slaves = [ mock.Mock() ]
         self.cfg.builders = [ b1, b2 ]
 
-    def setup_builder_locks(self, builder_lock=None, dup_builder_lock=False):
+    def setup_builder_locks(self,
+                            builder_lock=None,
+                            dup_builder_lock=False,
+                            bare_builder_lock=False):
+        """Set-up two mocked builders with specified locks.
+
+        @type  builder_lock: string or None
+        @param builder_lock: Name of the lock to add to first builder.
+                             If None, no lock is added.
+
+        @type dup_builder_lock: boolean
+        @param dup_builder_lock: if True, add a lock with duplicate name
+                                 to the second builder
+
+        @type dup_builder_lock: boolean
+        @param bare_builder_lock: if True, add bare lock objects, don't wrap
+                                  them into locks.LockAccess object
+        """
         def bldr(name):
             b = mock.Mock()
             b.name = name
@@ -713,9 +784,11 @@ def bldr(name):
             return b
 
         def lock(name):
-            l = mock.Mock()
+            l = mock.Mock(spec=locks.MasterLock)
             l.name = name
-            return l
+            if bare_builder_lock:
+                return l
+            return locks.LockAccess(l, "counting")
 
         b1, b2 = bldr('b1'), bldr('b2')
         self.cfg.builders = [ b1, b2 ]
@@ -781,6 +854,14 @@ def test_check_locks_none(self):
         self.cfg.check_locks()
         self.assertNoConfigErrors(self.errors)
 
+    def test_check_locks_bare(self):
+        # check_locks() should be able to handle bare lock object,
+        # lock objects that are not wrapped into LockAccess() object
+        self.setup_builder_locks(builder_lock='oldlock',
+                                 bare_builder_lock=True)
+        self.cfg.check_locks()
+        self.assertNoConfigErrors(self.errors)
+
 
     def test_check_builders_unknown_slave(self):
         sl = mock.Mock()
@@ -931,6 +1012,30 @@ def test_bogus_category(self):
             lambda : config.BuilderConfig(category=13,
                 name='a', slavenames=['a'], factory=self.factory))
 
+    def test_inv_nextSlave(self):
+        self.assertRaisesConfigError(
+            "nextSlave must be a callable",
+            lambda : config.BuilderConfig(nextSlave="foo",
+                name="a", slavenames=['a'], factory=self.factory))
+
+    def test_inv_nextBuild(self):
+        self.assertRaisesConfigError(
+            "nextBuild must be a callable",
+            lambda : config.BuilderConfig(nextBuild="foo",
+                name="a", slavenames=['a'], factory=self.factory))
+
+    def test_inv_canStartBuild(self):
+        self.assertRaisesConfigError(
+            "canStartBuild must be a callable",
+            lambda : config.BuilderConfig(canStartBuild="foo",
+                name="a", slavenames=['a'], factory=self.factory))
+
+    def test_inv_env(self):
+        self.assertRaisesConfigError(
+            "builder's env must be a dictionary",
+            lambda : config.BuilderConfig(env="foo",
+                name="a", slavenames=['a'], factory=self.factory))
+
     def test_defaults(self):
         cfg = config.BuilderConfig(
             name='a b c', slavename='a', factory=self.factory)