Ejemplo n.º 1
0
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')
Ejemplo n.º 2
0
 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')
Ejemplo n.º 3
0
    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
Ejemplo n.º 9
0
    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
Ejemplo n.º 10
0
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')
Ejemplo n.º 11
0
    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')
Ejemplo n.º 12
0
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)