class TestChangeProperties(unittest.TestCase): def setUp(self): self.basedir = "ChangeProperties" if os.path.exists(self.basedir): shutil.rmtree(self.basedir) os.makedirs(self.basedir) self.spec = DBSpec.from_url("sqlite:///state.sqlite", self.basedir) self.sm = manager.DBSchemaManager(self.spec, self.basedir) self.sm.upgrade(quiet=True) self.db = DBConnector(self.spec) self.db.start() def tearDown(self): self.db.stop() shutil.rmtree(self.basedir) def testDBGetChangeNumberedNow(self): db = self.db c = Change(who="catlee", files=["foo"], comments="", branch="b1") c.properties.setProperty("foo", "bar", "property_source") db.addChangeToDatabase(c) c1 = db.getChangeNumberedNow(c.number) self.assertEquals(c1.properties, c.properties) # Flush the cache db._change_cache = util.LRUCache() c1 = db.getChangeNumberedNow(c.number) self.assertEquals(c1.properties, c.properties) def testDBGetChangeByNumber(self): db = self.db c = Change(who="catlee", files=["foo"], comments="", branch="b1") c.properties.setProperty("foo", "bar", "property_source") db.addChangeToDatabase(c) d = db.getChangeByNumber(c.number) def check(c1): self.assertEquals(c1.properties, c.properties) d.addCallback(check) def flush(ign): # Flush the cache db._change_cache = util.LRUCache() return db.getChangeByNumber(c.number) d.addCallback(flush) d.addCallback(check)
class TestWeirdChanges(unittest.TestCase): def setUp(self): self.basedir = "WeirdChanges" if os.path.exists(self.basedir): shutil.rmtree(self.basedir) os.makedirs(self.basedir) # Now try the upgrade process, which will import the old changes. self.spec = DBSpec.from_url("sqlite:///state.sqlite", self.basedir) self.db = DBConnector(self.spec) self.db.start() def tearDown(self): if self.db: self.db.stop() if os.path.exists(self.basedir): shutil.rmtree(self.basedir) def mkchanges(self, changes): import buildbot.changes.changes cm = buildbot.changes.changes.OldChangeMaster() cm.changes = changes return cm def testListsAsFilenames(self): # Create changes.pck changes = [ Change(who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=[["foo", "bar"], ['bing']], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345) ] cPickle.dump(self.mkchanges(changes), open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(sorted(c.files), sorted([u"foo", u"bar", u"bing"]))
class TestWeirdChanges(unittest.TestCase): def setUp(self): self.basedir = "WeirdChanges" if os.path.exists(self.basedir): shutil.rmtree(self.basedir) os.makedirs(self.basedir) # Now try the upgrade process, which will import the old changes. self.spec = DBSpec.from_url("sqlite:///state.sqlite", self.basedir) self.db = DBConnector(self.spec) self.db.start() def tearDown(self): if self.db: self.db.stop() if os.path.exists(self.basedir): shutil.rmtree(self.basedir) def mkchanges(self, changes): import buildbot.changes.changes cm = buildbot.changes.changes.OldChangeMaster() cm.changes = changes return cm def testListsAsFilenames(self): # Create changes.pck changes = [Change(who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=[["foo","bar"],['bing']], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345)] cPickle.dump(self.mkchanges(changes), open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(sorted(c.files), sorted([u"foo", u"bar", u"bing"]))
class TestUnicodeChanges(unittest.TestCase): def setUp(self): self.basedir = "UnicodeChanges" if os.path.exists(self.basedir): shutil.rmtree(self.basedir) os.makedirs(self.basedir) # Now try the upgrade process, which will import the old changes. self.spec = DBSpec.from_url("sqlite:///state.sqlite", self.basedir) self.db = DBConnector(self.spec) self.db.start() def tearDown(self): if self.db: self.db.stop() def mkchanges(self, changes): import buildbot.changes.changes cm = buildbot.changes.changes.OldChangeMaster() cm.changes = changes return cm def testUnicodeChange(self): # Create changes.pck changes = [Change(who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345)] cPickle.dump(self.mkchanges(changes), open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") def testNonUnicodeChange(self): # Create changes.pck changes = [Change(who="\xff\xff\x00", files=["foo"], comments="\xff\xff\x00", branch="b1", revision=12345)] cPickle.dump(self.mkchanges(changes), open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) self.assertRaises(UnicodeError, lambda : sm.upgrade(quiet=True)) def testAsciiChange(self): # Create changes.pck changes = [Change(who="Frosty the Snowman", files=["foo"], comments="Frosty the Snowman", branch="b1", revision=12345)] cPickle.dump(self.mkchanges(changes), open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, "Frosty the Snowman") self.assertEquals(c.comments, "Frosty the Snowman") def testUTF16Change(self): # Create changes.pck cm = OldChangeMaster() cm.changes = [Change(who=u"Frosty the \N{SNOWMAN}".encode("utf16"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf16"), branch="b1", revision=12345)] # instead of running contrib/fix_changes_pickle_encoding.py, we just call # the changemanager's recode_changes directly - it's the function at the # heart of the script anyway. cm.recode_changes('utf16', quiet=True) # and dump the recoded changemanager to changes.pck before trying a schema upgrade cPickle.dump(cm, open(os.path.join(self.basedir, "changes.pck"), "wb")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}")
class TestUnicodeChanges(change_import.ChangeImportMixin, unittest.TestCase): def setUp(self): d = self.setUpChangeImport() self.db = DBConnector(self.db_url, self.basedir) def make_dbc(_): self.db = DBConnector(self.db_url, self.basedir) d.addCallback(make_dbc) # note the connector isn't started, as we're testing upgrades return d def tearDown(self): if self.db: self.db.stop() return self.tearDownChangeImport() def testUnicodeChange(self): self.make_pickle( self.make_change( who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345)) d = self.db.model.upgrade() d.addCallback(lambda _ : self.db.start()) d.addCallback(lambda _ : self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") d.addCallback(check) return d def testNonUnicodeChange(self): self.make_pickle( self.make_change( who="\xff\xff\x00", files=["foo"], comments="\xff\xff\x00", branch="b1", revision=12345)) d = self.db.model.upgrade() def eb(f): self.failUnless("UnicodeError" in str(f)) def cb(r): self.fail("upgrade did not fail for non-unicode changes") d.addCallbacks(cb, eb) return d def testAsciiChange(self): self.make_pickle( self.make_change( who="Frosty the Snowman", files=["foo"], comments="Frosty the Snowman", branch="b1", revision=12345)) d = self.db.model.upgrade() d.addCallback(lambda _ : self.db.start()) d.addCallback(lambda _ : self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, "Frosty the Snowman") self.assertEquals(c.comments, "Frosty the Snowman") d.addCallback(check) return d def testUTF16Change(self): self.make_pickle( self.make_change( who=u"Frosty the \N{SNOWMAN}".encode("utf16"), files=[u"foo".encode('utf16')], comments=u"Frosty the \N{SNOWMAN}".encode("utf16"), branch="b1", revision=12345), # instead of running contrib/fix_changes_pickle_encoding.py, we # just call the changemanager's recode_changes directly - it's # the function at the heart of the script anyway. recode_fn=lambda cm : cm.recode_changes('utf16', quiet=True)) d = self.db.model.upgrade() d.addCallback(lambda _ : self.db.start()) d.addCallback(lambda _ : self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") d.addCallback(check) return d
class TestUnicodeChanges(change_import.ChangeImportMixin, unittest.TestCase): def setUp(self): d = self.setUpChangeImport() self.db = DBConnector(mock.Mock(), self.db_url, self.basedir) def make_dbc(_): self.db = DBConnector(mock.Mock(), self.db_url, self.basedir) d.addCallback(make_dbc) # note the connector isn't started, as we're testing upgrades return d def tearDown(self): if self.db: self.db.stop() return self.tearDownChangeImport() def testUnicodeChange(self): self.make_pickle( self.make_change(who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345)) d = self.db.model.upgrade() d.addCallback(lambda _: self.db.start()) d.addCallback(lambda _: self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") d.addCallback(check) return d def testNonUnicodeChange(self): self.make_pickle( self.make_change(who="\xff\xff\x00", files=["foo"], comments="\xff\xff\x00", branch="b1", revision=12345)) d = self.db.model.upgrade() def eb(f): self.failUnless("UnicodeError" in str(f)) def cb(r): self.fail("upgrade did not fail for non-unicode changes") d.addCallbacks(cb, eb) return d def testAsciiChange(self): self.make_pickle( self.make_change(who="Frosty the Snowman", files=["foo"], comments="Frosty the Snowman", branch="b1", revision=12345)) d = self.db.model.upgrade() d.addCallback(lambda _: self.db.start()) d.addCallback(lambda _: self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, "Frosty the Snowman") self.assertEquals(c.comments, "Frosty the Snowman") d.addCallback(check) return d def testUTF16Change(self): self.make_pickle( self.make_change( who=u"Frosty the \N{SNOWMAN}".encode("utf16"), files=[u"foo".encode('utf16')], comments=u"Frosty the \N{SNOWMAN}".encode("utf16"), branch="b1", revision=12345), # instead of running contrib/fix_changes_pickle_encoding.py, we # just call the changemanager's recode_changes directly - it's # the function at the heart of the script anyway. recode_fn=lambda cm: cm.recode_changes('utf16', quiet=True)) d = self.db.model.upgrade() d.addCallback(lambda _: self.db.start()) d.addCallback(lambda _: self.db.changes.getChangeInstance(1)) def check(c): self.failIf(c is None) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") d.addCallback(check) return d
class TestUnicodeChanges(unittest.TestCase): def setUp(self): self.basedir = "UnicodeChanges" if os.path.exists(self.basedir): shutil.rmtree(self.basedir) os.makedirs(self.basedir) # Now try the upgrade process, which will import the old changes. self.spec = DBSpec.from_url("sqlite:///state.sqlite", self.basedir) self.db = DBConnector(self.spec) self.db.start() def tearDown(self): if self.db: self.db.stop() def testUnicodeChange(self): # Create changes.pck changes = [ Change(who=u"Frosty the \N{SNOWMAN}".encode("utf8"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf8"), branch="b1", revision=12345) ] cPickle.dump(Thing(changes=changes), open(os.path.join(self.basedir, "changes.pck"), "w")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}") def testNonUnicodeChange(self): # Create changes.pck changes = [ Change(who="\xff\xff\x00", files=["foo"], comments="\xff\xff\x00", branch="b1", revision=12345) ] cPickle.dump(Thing(changes=changes), open(os.path.join(self.basedir, "changes.pck"), "w")) sm = manager.DBSchemaManager(self.spec, self.basedir) self.assertRaises(UnicodeError, lambda: sm.upgrade(quiet=True)) def testAsciiChange(self): # Create changes.pck changes = [ Change(who="Frosty the Snowman", files=["foo"], comments="Frosty the Snowman", branch="b1", revision=12345) ] cPickle.dump(Thing(changes=changes), open(os.path.join(self.basedir, "changes.pck"), "w")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, "Frosty the Snowman") self.assertEquals(c.comments, "Frosty the Snowman") def testUTF16Change(self): # Create changes.pck cm = OldChangeMaster() cm.changes = [ Change(who=u"Frosty the \N{SNOWMAN}".encode("utf16"), files=["foo"], comments=u"Frosty the \N{SNOWMAN}".encode("utf16"), branch="b1", revision=12345) ] # instead of running contrib/fix_changes_pickle_encoding.py, we just call # the changemanager's recode_changes directly - it's the function at the # heart of the script anyway. cm.recode_changes('utf16', quiet=True) # and dump the recoded changemanager to changes.pck before trying a schema upgrade cPickle.dump(cm, open(os.path.join(self.basedir, "changes.pck"), "w")) sm = manager.DBSchemaManager(self.spec, self.basedir) sm.upgrade(quiet=True) c = self.db.getChangeNumberedNow(1) self.assertEquals(c.who, u"Frosty the \N{SNOWMAN}") self.assertEquals(c.comments, u"Frosty the \N{SNOWMAN}")