def upgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
# Add the new columns
op.add_column('releases', sa.Column('stable_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('testing_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('candidate_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('pending_testing_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('pending_stable_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('override_tag', sa.UnicodeText()))
# Add values for all releases in those new columns
with transaction.manager:
for r in DBSession.query(Release):
r.stable_tag = "%s-updates" % r.dist_tag
r.testing_tag = "%s-testing" % r.stable_tag
r.candidate_tag = "%s-candidate" % r.stable_tag
r.pending_testing_tag = "%s-pending" % r.testing_tag
r.pending_stable_tag = "%s-pending" % r.stable_tag
r.override_tag = "%s-override" % r.dist_tag
# Now make the new columns not-nullable
op.alter_column('releases', 'stable_tag', nullable=False)
op.alter_column('releases', 'testing_tag', nullable=False)
op.alter_column('releases', 'candidate_tag', nullable=False)
op.alter_column('releases', 'pending_testing_tag', nullable=False)
op.alter_column('releases', 'pending_stable_tag', nullable=False)
op.alter_column('releases', 'override_tag', nullable=False)
# And drop the old columns
op.drop_column('releases', '_stable_tag')
op.drop_column('releases', '_testing_tag')
op.drop_column('releases', '_candidate_tag')
def test_post_json_comment(self):
self.app.post_json('/comments/', self.make_comment(text='awesome'))
session = DBSession()
up = session.query(Update).filter_by(title='bodhi-2.0-1.fc17').one()
session.close()
self.assertEquals(len(up.comments), 3)
self.assertEquals(up.comments[-1]['text'], 'awesome')
def test_list_releases_by_update_alias(self):
session = DBSession()
update = session.query(Update).first()
update.alias = u'some_alias'
session.flush()
res = self.app.get('/releases/', {"updates": 'some_alias'})
body = res.json_body
self.assertEquals(len(body['releases']), 1)
self.assertEquals(body['releases'][0]['name'], 'F17')
def downgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
with transaction.manager:
updates = DBSession.query(Update)
for u in updates:
u.critpath = None
def upgrade():
op.add_column('releases', sa.Column('branch', sa.Unicode(length=10)))
op.create_unique_constraint(None, 'releases', ['branch'])
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
with transaction.manager:
for release in DBSession.query(Release).all():
release.branch = release.name.lower()
def upgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
with transaction.manager:
updates = DBSession.query(Update)
for u in updates:
if u.suggest is None:
u.suggest = UpdateSuggestion.unspecified
def upgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
with transaction.manager:
updates = DBSession.query(Update)
for u in updates:
if u.pushed is None:
u.pushed = False
def upgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
critpath_pkgs = {}
for release in DBSession.query(Release):
relname = release.name
critpath_pkgs[relname] = sorted(get_critpath_pkgs(relname.lower()))
with transaction.manager:
updates = DBSession.query(Update)
for up in updates:
for build in up.builds:
if build.package.name in critpath_pkgs[up.release.name]:
up.critpath = True
break
else:
up.critpath = False
def test_no_self_karma(self):
" Make sure you can't give +1 karma to your own updates.. "
comment = self.make_comment('bodhi-2.0-1.fc17', karma=1)
# The author of this comment is "guest"
session = DBSession()
up = session.query(Update).filter_by(title='bodhi-2.0-1.fc17').one()
self.assertEquals(up.user.name, 'guest')
r = self.app.post_json('/comments/', comment)
comment = r.json_body['comment']
self.assertEquals(comment['user']['name'], u'guest')
self.assertEquals(comment['update']['title'], u'bodhi-2.0-1.fc17')
caveats = r.json_body['caveats']
self.assertEquals(len(caveats), 1)
self.assertEquals(caveats[0]['name'], 'karma')
self.assertEquals(caveats[0]['description'],
"You may not give karma to your own updates.")
self.assertEquals(comment['karma'], 0) # This is the real check
def downgrade():
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
# Add the old columns
op.add_column('releases', sa.Column('_stable_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('_testing_tag', sa.UnicodeText()))
op.add_column('releases', sa.Column('_candidate_tag', sa.UnicodeText()))
with transaction.manager:
for r in DBSession.query(Release):
r._stable_tag = r.stable_tag
r._testing_tag = r.testing_tag
r._candidate_tag = r.candidate_tag
# And drop the new columns
op.drop_column('releases', 'stable_tag')
op.drop_column('releases', 'testing_tag')
op.drop_column('releases', 'candidate_tag')
op.drop_column('releases', 'pending_testing_tag')
op.drop_column('releases', 'pending_stable_tag')
op.drop_column('releases', 'override_tag')
def test_list_comments_by_since(self):
tomorrow = datetime.utcnow() + timedelta(days=1)
fmt = "%Y-%m-%d %H:%M:%S"
# Try with no comments first
res = self.app.get('/comments/', {"since": tomorrow.strftime(fmt)})
body = res.json_body
self.assertEquals(len(body['comments']), 0)
# Now change the time on one to tomorrow
session = DBSession()
session.query(Comment).first().timestamp = tomorrow
session.flush()
# And try again
res = self.app.get('/comments/', {"since": tomorrow.strftime(fmt)})
body = res.json_body
self.assertEquals(len(body['comments']), 1)
comment = body['comments'][0]
self.assertEquals(comment['text'], u'wow. amaze.')
self.assertEquals(comment['karma'], 1)
self.assertEquals(comment['user']['name'], u'guest')
class TestExtendedMetadata(unittest.TestCase):
def __init__(self, *args, **kw):
super(TestExtendedMetadata, self).__init__(*args, **kw)
repo_path = os.path.join(config.get("mash_dir"), "f17-updates-testing")
if not os.path.exists(repo_path):
os.makedirs(repo_path)
def setUp(self):
engine = create_engine(DB_PATH)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
self.db = DBSession()
populate(self.db)
# Initialize our temporary repo
self.tempdir = tempfile.mkdtemp("bodhi")
self.temprepo = join(self.tempdir, "f17-updates-testing")
mkmetadatadir(join(self.temprepo, "f17-updates-testing", "i386"))
self.repodata = join(self.temprepo, "f17-updates-testing", "i386", "repodata")
assert exists(join(self.repodata, "repomd.xml"))
DevBuildsys.__rpms__ = [
{
"arch": "src",
"build_id": 6475,
"buildroot_id": 1883,
"buildtime": 1178868422,
"epoch": None,
"id": 62330,
"name": "bodhi",
"nvr": "bodhi-2.0-1.fc17",
"release": "1.fc17",
"size": 761742,
"version": "2.0",
}
]
def tearDown(self):
DBSession.remove()
get_session().clear()
shutil.rmtree(self.tempdir)
def _verify_updateinfo(self, repodata):
updateinfos = glob.glob(join(repodata, "*-updateinfo.xml*"))
assert len(updateinfos) == 1, "We generated %d updateinfo metadata" % len(updateinfos)
updateinfo = updateinfos[0]
hash = basename(updateinfo).split("-", 1)[0]
hashed = sha256(open(updateinfo).read()).hexdigest()
assert hash == hashed, "File: %s\nHash: %s" % (basename(updateinfo), hashed)
return updateinfo
def get_notice(self, uinfo, title):
for record in uinfo.updates:
if record.title == title:
return record
def test_extended_metadata(self):
update = self.db.query(Update).one()
# Pretend it's pushed to testing
update.status = UpdateStatus.testing
update.request = None
update.date_pushed = datetime.utcnow()
DevBuildsys.__tagged__[update.title] = ["f17-updates-testing"]
# Generate the XML
md = ExtendedMetadata(update.release, update.request, self.db, self.temprepo)
# Insert the updateinfo.xml into the repository
md.insert_updateinfo()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, "mutt-1.5.14-1.fc13")
self.assertIsNone(notice)
self.assertEquals(len(uinfo.updates), 1)
notice = uinfo.updates[0]
self.assertIsNotNone(notice)
self.assertEquals(notice.title, update.title)
self.assertEquals(notice.release, update.release.long_name)
self.assertEquals(notice.status, update.status.value)
if update.date_modified:
self.assertEquals(notice.updated_date, update.date_modified)
self.assertEquals(notice.fromstr, config.get("bodhi_email"))
self.assertEquals(notice.rights, config.get("updateinfo_rights"))
self.assertEquals(notice.description, update.notes)
# self.assertIsNotNone(notice.issued_date)
self.assertEquals(notice.id, update.alias)
bug = notice.references[0]
self.assertEquals(bug.href, update.bugs[0].url)
self.assertEquals(bug.id, "12345")
self.assertEquals(bug.type, "bugzilla")
cve = notice.references[1]
self.assertEquals(cve.type, "cve")
self.assertEquals(cve.href, update.cves[0].url)
self.assertEquals(cve.id, update.cves[0].cve_id)
col = notice.collections[0]
self.assertEquals(col.name, update.release.long_name)
self.assertEquals(col.shortname, update.release.name)
pkg = col.packages[0]
self.assertEquals(pkg.epoch, "0")
self.assertEquals(pkg.name, "TurboGears")
self.assertEquals(
pkg.src,
"https://download.fedoraproject.org/pub/fedora/linux/updates/testing/17/SRPMS/T/TurboGears-1.0.2.2-2.fc7.src.rpm",
)
self.assertEquals(pkg.version, "1.0.2.2")
self.assertFalse(pkg.reboot_suggested)
self.assertEquals(pkg.arch, "src")
self.assertEquals(pkg.filename, "TurboGears-1.0.2.2-2.fc7.src.rpm")
def test_extended_metadata_updating(self):
update = self.db.query(Update).one()
# Pretend it's pushed to testing
update.status = UpdateStatus.testing
update.request = None
update.date_pushed = datetime.utcnow()
DevBuildsys.__tagged__[update.title] = ["f17-updates-testing"]
# Generate the XML
md = ExtendedMetadata(update.release, update.request, self.db, self.temprepo)
# Insert the updateinfo.xml into the repository
md.insert_updateinfo()
md.cache_repodata()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
self.assertEquals(notice.title, update.title)
self.assertEquals(notice.release, update.release.long_name)
self.assertEquals(notice.status, update.status.value)
self.assertEquals(notice.updated_date, update.date_modified)
self.assertEquals(notice.fromstr, config.get("bodhi_email"))
self.assertEquals(notice.description, update.notes)
# self.assertIsNotNone(notice.issued_date)
self.assertEquals(notice.id, update.alias)
# self.assertIsNone(notice.epoch)
bug = notice.references[0]
url = update.bugs[0].url
self.assertEquals(bug.href, url)
self.assertEquals(bug.id, "12345")
self.assertEquals(bug.type, "bugzilla")
cve = notice.references[1]
self.assertEquals(cve.type, "cve")
self.assertEquals(cve.href, update.cves[0].url)
self.assertEquals(cve.id, update.cves[0].cve_id)
# Change the notes on the update, but not the date_modified, so we can
# ensure that the notice came from the cache
update.notes = u"x"
# Re-initialize our temporary repo
shutil.rmtree(self.temprepo)
os.mkdir(self.temprepo)
mkmetadatadir(join(self.temprepo, "f17-updates-testing", "i386"))
md = ExtendedMetadata(update.release, update.request, self.db, self.temprepo)
md.insert_updateinfo()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
self.assertEquals(notice.description, u"Useful details!") # not u'x'
def test_metadata_updating_with_edited_update(self):
update = self.db.query(Update).one()
# Pretend it's pushed to testing
update.status = UpdateStatus.testing
update.request = None
update.date_pushed = datetime.utcnow()
DevBuildsys.__tagged__[update.title] = ["f17-updates-testing"]
# Generate the XML
md = ExtendedMetadata(update.release, update.request, self.db, self.temprepo)
# Insert the updateinfo.xml into the repository
md.insert_updateinfo()
md.cache_repodata()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
self.assertEquals(notice.title, update.title)
self.assertEquals(notice.release, update.release.long_name)
self.assertEquals(notice.status, update.status.value)
self.assertEquals(notice.updated_date, update.date_modified)
self.assertEquals(notice.fromstr, config.get("bodhi_email"))
self.assertEquals(notice.description, update.notes)
self.assertIsNotNone(notice.issued_date)
self.assertEquals(notice.id, update.alias)
# self.assertIsNone(notice.epoch)
bug = notice.references[0]
self.assertEquals(bug.href, update.bugs[0].url)
self.assertEquals(bug.id, "12345")
self.assertEquals(bug.type, "bugzilla")
cve = notice.references[1]
self.assertEquals(cve.type, "cve")
self.assertEquals(cve.href, update.cves[0].url)
self.assertEquals(cve.id, update.cves[0].cve_id)
# Change the notes on the update *and* the date_modified
update.notes = u"x"
update.date_modified = datetime.utcnow()
# Re-initialize our temporary repo
shutil.rmtree(self.temprepo)
os.mkdir(self.temprepo)
mkmetadatadir(join(self.temprepo, "f17-updates-testing", "i386"))
md = ExtendedMetadata(update.release, update.request, self.db, self.temprepo)
md.insert_updateinfo()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
self.assertEquals(notice.description, u"x")
self.assertEquals(
notice.updated_date.strftime("%Y-%m-%d %H:%M:%S"), update.date_modified.strftime("%Y-%m-%d %H:%M:%S")
)
def test_metadata_updating_with_old_stable_security(self):
update = self.db.query(Update).one()
update.request = None
update.type = UpdateType.security
update.status = UpdateStatus.stable
update.date_pushed = datetime.utcnow()
DevBuildsys.__tagged__[update.title] = ["f17-updates"]
repo = join(self.tempdir, "f17-updates")
mkmetadatadir(join(repo, "f17-updates", "i386"))
self.repodata = join(repo, "f17-updates", "i386", "repodata")
# Generate the XML
md = ExtendedMetadata(update.release, UpdateRequest.stable, self.db, repo)
# Insert the updateinfo.xml into the repository
md.insert_updateinfo()
md.cache_repodata()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
# Create a new non-security update for the same package
newbuild = "bodhi-2.0-2.fc17"
pkg = self.db.query(Package).filter_by(name=u"bodhi").one()
build = Build(nvr=newbuild, package=pkg)
self.db.add(build)
self.db.flush()
newupdate = Update(
title=newbuild,
type=UpdateType.enhancement,
status=UpdateStatus.stable,
request=None,
release=update.release,
builds=[build],
notes=u"x",
)
newupdate.assign_alias()
self.db.add(newupdate)
self.db.flush()
# Untag the old security build
DevBuildsys.__untag__.append(update.title)
DevBuildsys.__tagged__[newupdate.title] = [newupdate.release.stable_tag]
buildrpms = DevBuildsys.__rpms__[0].copy()
buildrpms["nvr"] = "bodhi-2.0-2.fc17"
buildrpms["release"] = "2.fc17"
DevBuildsys.__rpms__.append(buildrpms)
# Re-initialize our temporary repo
shutil.rmtree(repo)
os.mkdir(repo)
mkmetadatadir(join(repo, "f17-updates", "i386"))
md = ExtendedMetadata(update.release, UpdateRequest.stable, self.db, repo)
md.insert_updateinfo()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
self.assertEquals(len(uinfo.updates), 2)
notice = self.get_notice(uinfo, "bodhi-2.0-1.fc17")
self.assertIsNotNone(notice)
notice = self.get_notice(uinfo, "bodhi-2.0-2.fc17")
self.assertIsNotNone(notice)
def test_metadata_updating_with_old_testing_security(self):
update = self.db.query(Update).one()
update.request = None
update.type = UpdateType.security
update.status = UpdateStatus.testing
update.date_pushed = datetime.utcnow()
DevBuildsys.__tagged__[update.title] = ["f17-updates-testing"]
# Generate the XML
md = ExtendedMetadata(update.release, UpdateRequest.testing, self.db, self.temprepo)
# Insert the updateinfo.xml into the repository
md.insert_updateinfo()
md.cache_repodata()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
notice = self.get_notice(uinfo, update.title)
self.assertIsNotNone(notice)
# Create a new non-security update for the same package
newbuild = "bodhi-2.0-2.fc17"
pkg = self.db.query(Package).filter_by(name=u"bodhi").one()
build = Build(nvr=newbuild, package=pkg)
self.db.add(build)
self.db.flush()
newupdate = Update(
title=newbuild,
type=UpdateType.enhancement,
status=UpdateStatus.testing,
request=None,
release=update.release,
builds=[build],
notes=u"x",
)
newupdate.assign_alias()
self.db.add(newupdate)
self.db.flush()
# Untag the old security build
del (DevBuildsys.__tagged__[update.title])
DevBuildsys.__untag__.append(update.title)
DevBuildsys.__tagged__[newupdate.title] = [newupdate.release.testing_tag]
buildrpms = DevBuildsys.__rpms__[0].copy()
buildrpms["nvr"] = "bodhi-2.0-2.fc17"
buildrpms["release"] = "2.fc17"
DevBuildsys.__rpms__.append(buildrpms)
del (DevBuildsys.__rpms__[0])
# Re-initialize our temporary repo
shutil.rmtree(self.temprepo)
os.mkdir(self.temprepo)
mkmetadatadir(join(self.temprepo, "f17-updates-testing", "i386"))
md = ExtendedMetadata(update.release, UpdateRequest.testing, self.db, self.temprepo)
md.insert_updateinfo()
updateinfo = self._verify_updateinfo(self.repodata)
# Read an verify the updateinfo.xml.gz
uinfo = createrepo_c.UpdateInfo(updateinfo)
self.assertEquals(len(uinfo.updates), 1)
notice = self.get_notice(uinfo, "bodhi-2.0-1.fc17")
self.assertIsNone(notice)
notice = self.get_notice(uinfo, "bodhi-2.0-2.fc17")
self.assertIsNotNone(notice)
