def setup(self):
     super(TestChangesetRegister, self).setup()
     self.changesets = ChangesetRegister()
     self.revisions = RevisionRegister()
     self.packages = PackageRegister()
     self.changes = ChangeRegister()
Example #2
0
 def setup(self):
     super(TestChangesetRegister, self).setup()
     self.changesets = ChangesetRegister()
     self.revisions = RevisionRegister()
     self.packages = PackageRegister()
     self.changes = ChangeRegister()
class TestChangesetRegister(TestCase):

    def setup(self):
        super(TestChangesetRegister, self).setup()
        self.changesets = ChangesetRegister()
        self.revisions = RevisionRegister()
        self.packages = PackageRegister()
        self.changes = ChangeRegister()

    def teardown(self):
        self.changesets = None
        for name in [u'annie', u'annie1', u'annie2']:
            annie = self.packages.get(name, None, attr='name')
            if annie:
                annie.purge()
        model.Session.commit()
        model.Session.remove()
        super(TestChangesetRegister, self).teardown()
   
    def test_commit(self):
        revision_id = self.build_creating_revision()
        revision = self.revisions[revision_id]
        changeset_ids = self.changesets.commit()
        working = self.changesets.get_working()
        self.assert_true(working)
        self.assert_equal(len(changeset_ids), 2)
        changeset0 = self.changesets.get(changeset_ids[0])
        self.assert_false(changeset0.is_working)
        changeset1 = self.changesets.get(changeset_ids[1])
        self.assert_true(changeset1.is_working)
        self.assert_equal(changeset0.id, changeset1.follows_id)
        
    def test_update(self):
        self.assert_false(self.changesets.get_working())
        changeset_id = self.build_creating_changeset()
        self.assert_raises(UncommittedChangesException, self.changesets.update)
        new_changeset_ids = self.changesets.commit()
        self.assert_equal(len(new_changeset_ids), 1)
        self.assert_raises(WorkingAtHeadException, self.changesets.update)
        self.assert_true(self.changesets.get_working())
        self.assert_equal(self.changesets.get_working().id, new_changeset_ids[0])
        changeset_id = self.build_creating_changeset('1', follows_id=self.changesets.get_working().id)
        self.assert_equal(len(self.packages), 0)
        report = {}
        self.changesets.update(report=report)
        # Check changesets have been applied.
        self.assert_equal(len(report['created']), 1)
        self.assert_equal(len(self.packages), 1)
        self.assert_equal(self.changesets.get_working().id, changeset_id)
        self.assert_raises(WorkingAtHeadException, self.changesets.update)

    def test_construct_from_revision(self):
        revision_id = self.build_creating_revision()
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)
        
        revision_id = self.build_creating_revision('1')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        revision_id = self.build_updating_revision('', 'and also')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        revision_id = self.build_updating_revision('1', 'and now')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        data = changeset.as_dict()
        self.assert_true(data['id'])
        self.assert_true(data['meta'])
        self.assert_true(data['changes'])
        meta = data['meta']
        self.assert_true('log_message' in meta)
        self.assert_true('author' in meta)
        self.assert_true('timestamp' in meta)
        changes = data['changes']
        self.assert_true(changes[0]['ref'])
        self.assert_true(changes[0]['diff'])
        diff = changes[0]['diff']
        self.assert_true(diff['new'])
        self.assert_true(diff['old'])

    def test_conflict(self):
        self.assert_equal(len(self.packages), 0)
        changeset_id = self.build_creating_changeset()
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 1)

        changeset_id = self.build_creating_changeset("1")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_conflicting_changeset("", "orig", "corr")
        changeset = self.changesets[changeset_id]
        self.assert_true(changeset.is_conflicting())
        self.assert_false(changeset.revision_id)
        self.assert_raises(ConflictException, changeset.apply)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply(is_forced=True)
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "closed-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_conflicting_changeset("1", "orig", "corr")
        changeset = self.changesets[changeset_id]
        self.assert_true(changeset.is_conflicting())
        self.assert_false(changeset.revision_id)
        self.assert_raises(ConflictException, changeset.apply)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply(is_forced=True)
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "closed-corr")

    def test_apply(self):
        self.assert_equal(len(self.packages), 0)
        changeset_id = self.build_creating_changeset()
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 1)

        changeset_id = self.build_creating_changeset("1")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 2)
        
        changeset_id = self.build_updating_changeset("", "orig", "corr")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "open-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("1", "orig", "corr")
        count_before = len(self.revisions)
        changeset = self.changesets[changeset_id]
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "open-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("", "corr", "draft")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (draft)")
        self.assert_equal(package.license_id, "open-draft")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("1", "corr", "draft")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (draft)")
        self.assert_equal(package.license_id, "open-draft")

        self.assert_equal(len(self.packages), 2)

    def build_creating_revision(self, mark=''):
        revision = self.revisions.create_entity(author=u'test', log_message=u'test')
        package = self.packages.create_entity(name=u'annie%s'%mark, title=u'Annie Get Your Coat (%s)'%mark)
        model.Session.add(package)
        model.Session.commit()
        model.Session.remove()
        setup_default_user_roles(package, [])
        self.assert_true(revision.id)
        self.assert_true(package.id)
        self.assert_true(revision.packages)
        return revision.id

    def build_updating_revision(self, mark='', vary_new=''):
        revision = self.revisions.create_entity(author=u'test', log_message=u'test')
        package = self.packages.get(u'annie%s'%mark, attr="name")
        package.title = u'Annie Get Your Coat (%s)' % vary_new
        model.Session.commit()
        model.Session.remove()
        self.assert_true(revision.id)
        self.assert_true(package.id)
        self.assert_true(revision.packages)
        return revision.id

    def build_creating_changeset(self, mark='', follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        vary = 'orig'
        diff = u"""{
            "old": null,
            "new": {
                "name": "annie%s",
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            }
        }""" % (mark, vary, vary)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change], 
        )
        model.Session.add(changeset)
        model.Session.commit()
        assert changeset.id
        return changeset.id

    def build_updating_changeset(self, mark='', vary_old='', vary_new='', follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        diff = u"""{
            "old": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            },
            "new": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            }
        }""" % (vary_old, vary_old, vary_new, vary_new)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change],
        )
        model.Session.add(changeset)
        model.Session.commit()
        return changeset.id

    def build_conflicting_changeset(self, mark='', vary_old='', vary_new='', follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        diff = u"""{
            "old": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "closed-%s"
            },
            "new": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "closed-%s"
            }
        }""" % (vary_old, vary_old, vary_new, vary_new)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change],
        )
        model.Session.add(changeset)
        model.Session.commit()
        return changeset.id

    def test_add_unseen(self):
        changeset_data = {
            "id": "8772c628-435e-4896-ad04-514aab3d0d10",
            "meta": {},
            "changes": [
                {
                    "ref": "/package/4662c628-435e-4896-ad04-514aab3d0e66",
                    "diff": {
                        "new": {
                            "name": "coat",
                            "title": "Annie Get Your Coat",
                            "license_id": "abcd3"
                        },
                        "old": {}
                    },

                }
            ]
        }
        changeset_id = self.changesets.add_unseen(changeset_data)
        changeset = ChangesetRegister()[changeset_id]
Example #4
0
class TestChangesetRegister(TestCase):
    def setup(self):
        super(TestChangesetRegister, self).setup()
        self.changesets = ChangesetRegister()
        self.revisions = RevisionRegister()
        self.packages = PackageRegister()
        self.changes = ChangeRegister()

    def teardown(self):
        self.changesets = None
        for name in [u'annie', u'annie1', u'annie2']:
            annie = self.packages.get(name, None, attr='name')
            if annie:
                annie.purge()
        model.Session.commit()
        model.Session.remove()
        super(TestChangesetRegister, self).teardown()

    def test_commit(self):
        revision_id = self.build_creating_revision()
        revision = self.revisions[revision_id]
        changeset_ids = self.changesets.commit()
        working = self.changesets.get_working()
        self.assert_true(working)
        self.assert_equal(len(changeset_ids), 2)
        changeset0 = self.changesets.get(changeset_ids[0])
        self.assert_false(changeset0.is_working)
        changeset1 = self.changesets.get(changeset_ids[1])
        self.assert_true(changeset1.is_working)
        self.assert_equal(changeset0.id, changeset1.follows_id)

    def test_update(self):
        self.assert_false(self.changesets.get_working())
        changeset_id = self.build_creating_changeset()
        self.assert_raises(UncommittedChangesException, self.changesets.update)
        new_changeset_ids = self.changesets.commit()
        self.assert_equal(len(new_changeset_ids), 1)
        self.assert_raises(WorkingAtHeadException, self.changesets.update)
        self.assert_true(self.changesets.get_working())
        self.assert_equal(self.changesets.get_working().id,
                          new_changeset_ids[0])
        changeset_id = self.build_creating_changeset(
            '1', follows_id=self.changesets.get_working().id)
        self.assert_equal(len(self.packages), 0)
        report = {}
        self.changesets.update(report=report)
        # Check changesets have been applied.
        self.assert_equal(len(report['created']), 1)
        self.assert_equal(len(self.packages), 1)
        self.assert_equal(self.changesets.get_working().id, changeset_id)
        self.assert_raises(WorkingAtHeadException, self.changesets.update)

    def test_construct_from_revision(self):
        revision_id = self.build_creating_revision()
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        revision_id = self.build_creating_revision('1')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        revision_id = self.build_updating_revision('', 'and also')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        revision_id = self.build_updating_revision('1', 'and now')
        revision = self.revisions[revision_id]
        changeset_id = self.changesets.construct_from_revision(revision)
        changeset = self.changesets.get(changeset_id)
        self.assert_isinstance(changeset, Changeset)
        self.assert_true(changeset.revision_id)
        self.assert_true(changeset.changes)

        data = changeset.as_dict()
        self.assert_true(data['id'])
        self.assert_true(data['meta'])
        self.assert_true(data['changes'])
        meta = data['meta']
        self.assert_true('log_message' in meta)
        self.assert_true('author' in meta)
        self.assert_true('timestamp' in meta)
        changes = data['changes']
        self.assert_true(changes[0]['ref'])
        self.assert_true(changes[0]['diff'])
        diff = changes[0]['diff']
        self.assert_true(diff['new'])
        self.assert_true(diff['old'])

    def test_conflict(self):
        self.assert_equal(len(self.packages), 0)
        changeset_id = self.build_creating_changeset()
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 1)

        changeset_id = self.build_creating_changeset("1")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_conflicting_changeset("", "orig", "corr")
        changeset = self.changesets[changeset_id]
        self.assert_true(changeset.is_conflicting())
        self.assert_false(changeset.revision_id)
        self.assert_raises(ConflictException, changeset.apply)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply(is_forced=True)
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "closed-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_conflicting_changeset("1", "orig", "corr")
        changeset = self.changesets[changeset_id]
        self.assert_true(changeset.is_conflicting())
        self.assert_false(changeset.revision_id)
        self.assert_raises(ConflictException, changeset.apply)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply(is_forced=True)
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "closed-corr")

    def test_apply(self):
        self.assert_equal(len(self.packages), 0)
        changeset_id = self.build_creating_changeset()
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 1)

        changeset_id = self.build_creating_changeset("1")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (orig)")
        self.assert_equal(package.license_id, "open-orig")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("", "orig", "corr")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "open-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("1", "orig", "corr")
        count_before = len(self.revisions)
        changeset = self.changesets[changeset_id]
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (corr)")
        self.assert_equal(package.license_id, "open-corr")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("", "corr", "draft")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d10")
        self.assert_equal(package.name, "annie")
        self.assert_equal(package.title, "Annie Get Your Coat (draft)")
        self.assert_equal(package.license_id, "open-draft")

        self.assert_equal(len(self.packages), 2)

        changeset_id = self.build_updating_changeset("1", "corr", "draft")
        changeset = self.changesets[changeset_id]
        count_before = len(self.revisions)
        self.assert_false(changeset.revision_id)
        revision_id = changeset.apply()
        revision = self.revisions[revision_id]
        self.assert_true(changeset.revision_id)
        count_after = len(self.revisions)
        self.assert_isinstance(revision, model.Revision)
        self.assert_equal(count_after - count_before, 1)
        self.assert_true(revision.packages)
        package = revision.packages[0]
        self.assert_equal(package.id, "5872c628-435e-4896-ad04-514aab3d0d11")
        self.assert_equal(package.name, "annie1")
        self.assert_equal(package.title, "Annie Get Your Coat (draft)")
        self.assert_equal(package.license_id, "open-draft")

        self.assert_equal(len(self.packages), 2)

    def build_creating_revision(self, mark=''):
        revision = self.revisions.create_entity(author=u'test',
                                                log_message=u'test')
        package = self.packages.create_entity(
            name=u'annie%s' % mark, title=u'Annie Get Your Coat (%s)' % mark)
        model.Session.add(package)
        model.Session.commit()
        model.Session.remove()
        setup_default_user_roles(package, [])
        self.assert_true(revision.id)
        self.assert_true(package.id)
        self.assert_true(revision.packages)
        return revision.id

    def build_updating_revision(self, mark='', vary_new=''):
        revision = self.revisions.create_entity(author=u'test',
                                                log_message=u'test')
        package = self.packages.get(u'annie%s' % mark, attr="name")
        package.title = u'Annie Get Your Coat (%s)' % vary_new
        model.Session.commit()
        model.Session.remove()
        self.assert_true(revision.id)
        self.assert_true(package.id)
        self.assert_true(revision.packages)
        return revision.id

    def build_creating_changeset(self, mark='', follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        vary = 'orig'
        diff = u"""{
            "old": null,
            "new": {
                "name": "annie%s",
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            }
        }""" % (mark, vary, vary)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change],
        )
        model.Session.add(changeset)
        model.Session.commit()
        assert changeset.id
        return changeset.id

    def build_updating_changeset(self,
                                 mark='',
                                 vary_old='',
                                 vary_new='',
                                 follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        diff = u"""{
            "old": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            },
            "new": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "open-%s"
            }
        }""" % (vary_old, vary_old, vary_new, vary_new)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change],
        )
        model.Session.add(changeset)
        model.Session.commit()
        return changeset.id

    def build_conflicting_changeset(self,
                                    mark='',
                                    vary_old='',
                                    vary_new='',
                                    follows_id=None):
        id = u"5872c628-435e-4896-ad04-514aab3d0d10"
        if mark:
            assert len(mark) == 1
            id = list(id)
            id[-1] = mark
            id = u"".join(id)
        diff = u"""{
            "old": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "closed-%s"
            },
            "new": {
                "title": "Annie Get Your Coat (%s)",
                "license_id": "closed-%s"
            }
        }""" % (vary_old, vary_old, vary_new, vary_new)
        ref = u"/package/%s" % id
        change = self.changes.create_entity(diff=diff, ref=ref)
        changeset = self.changesets.create_entity(
            follows_id=follows_id,
            changes=[change],
        )
        model.Session.add(changeset)
        model.Session.commit()
        return changeset.id

    def test_add_unseen(self):
        changeset_data = {
            "id":
            "8772c628-435e-4896-ad04-514aab3d0d10",
            "meta": {},
            "changes": [{
                "ref": "/package/4662c628-435e-4896-ad04-514aab3d0e66",
                "diff": {
                    "new": {
                        "name": "coat",
                        "title": "Annie Get Your Coat",
                        "license_id": "abcd3"
                    },
                    "old": {}
                },
            }]
        }
        changeset_id = self.changesets.add_unseen(changeset_data)
        changeset = ChangesetRegister()[changeset_id]