예제 #1
0
    def test_creating_new_version_of_the_subdir(self):
        t1 = get_utc_now()

        subdir1_v1 = Directory.objects.current.get(name__startswith='subdir1')
        subdir1_v2 = subdir1_v1.clone()
        subdir1_v2.name = 'subdir1.v2'
        subdir1_v2.save()

        sleep(0.1)
        t2 = get_utc_now()

        # Count all Directory instance versions:
        # 3 initial versions + 2 subdirs added to parentdir (implies a clone) + 1 subdir1 that was explicitely cloned = 6
        self.assertEqual(6, Directory.objects.all().count())

        # at t1 there is no directory named 'subdir1.v2'
        parentdir_at_t1 = Directory.objects.as_of(t1).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.count())

        for subdir in parentdir_at_t1.directory_set.all():
            self.assertNotEqual('subdir1.v2', subdir.name)

        # at t2 there must be 2 directories and ...
        parentdir_at_t2 = Directory.objects.as_of(t2).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t2.directory_set.count())

        # ... and one of then is named 'subdir1.v2'
        if six.PY2:
            matches = itertools.ifilter(lambda x: x.name == 'subdir1.v2', parentdir_at_t2.directory_set.all())
        if six.PY3:
            matches = filter(lambda x: x.name == 'subdir1.v2', parentdir_at_t2.directory_set.all())
        self.assertEqual(1, len(list(matches)))
예제 #2
0
    def test_adding_more_subdir(self):
        t1 = get_utc_now()
        sleep(0.1)

        current_parentdir = Directory.objects.current.get(
            name__startswith='parent')
        self.assertEqual(2, current_parentdir.directory_set.all().count())
        sleep(0.1)

        Directory.objects.create(name='subdir3.v1', parent=current_parentdir)
        t2 = get_utc_now()

        # there must not be 3 subdirectories in the parent directory, since current_parentdir holds the state
        # at t1 - prior to adding "subdir3"
        self.assertNotEqual(3, current_parentdir.directory_set.all().count())
        # If we wanted this comparision to be equal, we'd need to removed the 'as_of' timestamp within 'current_parentdir'
        # Let's do that:
        current_parentdir.as_of = None
        self.assertEqual(3, current_parentdir.directory_set.all().count())

        # there should be 2 directories in the parent directory at time t1
        parentdir_at_t1 = Directory.objects.as_of(t1).filter(
            name='parent.v1').first()
        self.assertEqual(2, parentdir_at_t1.directory_set.all().count())

        # there should be 3 directories in the parent directory at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).filter(
            name='parent.v1').first()
        self.assertEqual(3, parentdir_at_t2.directory_set.all().count())
예제 #3
0
    def test_creating_new_version_of_parent_directory(self):
        t1 = get_utc_now()
        sleep(0.1)

        parentdir_v1 = Directory.objects.get(name__startswith='parent.v1')
        self.assertTrue(parentdir_v1.is_current)
        parentdir_v2 = parentdir_v1.clone()
        parentdir_v2.name = 'parent.v2'
        parentdir_v2.save()

        t2 = get_utc_now()

        # 1 parent dir, 2 subdirs, 2 new versions after linking then together
        # and 1 new version of the parent dir
        self.assertEqual(6, Directory.objects.all().count())

        self.assertTrue(parentdir_v2.is_current)

        # We didn't change anything to the subdirs so there must be 2 subdirs in
        # the parent at time t1...
        parentdir_at_t1 = Directory.objects.as_of(t1).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.count())

        # ... and at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t2.directory_set.count())
예제 #4
0
    def test_removing_and_then_adding_again_same_player(self):
        t1 = get_utc_now()
        sleep(0.1)

        p1 = self.p1.clone()
        p1.team = None
        p1.name = 'p1.v2'
        p1.save()

        t2 = get_utc_now()
        sleep(0.1)

        p1 = p1.clone()
        p1.team = self.team
        p1.name = 'p1.v3'
        p1.save()

        t3 = get_utc_now()

        # there should be 2 players in the team if we put ourselves back at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 1 players in the team if we put ourselves back at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(1, team_at_t2.player_set.all().count())
        p1_at_t2 = Player.objects.as_of(t2).get(name__startswith='p1')
        self.assertIsNone(p1_at_t2.team)

        # there should be 2 players in the team if we put ourselves back at time t3
        team_at_t3 = Team.objects.as_of(t3).first()
        self.assertEqual(2, team_at_t3.player_set.all().count())
예제 #5
0
    def setUp(self):
        billy = Pupil.objects.create(name='Billy', phone_number='123')
        erika = Pupil.objects.create(name='Erika', phone_number='456')

        ms_sue = Teacher.objects.create(name='Ms. Sue', domain='English')
        ms_klishina = Teacher.objects.create(name='Ms. Klishina',
                                             domain='Russian')

        mr_kazmirek = Teacher.objects.create(name='Mr. Kazmirek',
                                             domain='Math')
        ms_mayer = Teacher.objects.create(name='Ms. Mayer', domain='Chemistry')

        self.t0 = get_utc_now()
        sleep(0.1)

        billy.language_teachers.add(ms_sue)
        erika.science_teachers.add(mr_kazmirek, ms_mayer)

        self.t1 = get_utc_now()
        sleep(0.1)

        billy.language_teachers.add(ms_klishina)
        billy.language_teachers.remove(ms_sue)

        self.t2 = get_utc_now()
        sleep(0.1)

        erika.science_teachers.remove(ms_mayer)

        self.t3 = get_utc_now()
예제 #6
0
    def test_removing_and_then_adding_again_same_player(self):
        t1 = get_utc_now()
        sleep(0.1)

        p1 = self.p1.clone()
        p1.team = None
        p1.name = 'p1.v2'
        p1.save()

        t2 = get_utc_now()
        sleep(0.1)

        p1 = p1.clone()
        p1.team = self.team
        p1.name = 'p1.v3'
        p1.save()

        t3 = get_utc_now()

        # there should be 2 players in the team if we put ourselves back at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 1 players in the team if we put ourselves back at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(1, team_at_t2.player_set.all().count())
        p1_at_t2 = Player.objects.as_of(t2).get(name__startswith='p1')
        self.assertIsNone(p1_at_t2.team)

        # there should be 2 players in the team if we put ourselves back at time t3
        team_at_t3 = Team.objects.as_of(t3).first()
        self.assertEqual(2, team_at_t3.player_set.all().count())
예제 #7
0
    def test_simple_filter_using_q_objects(self):
        """
        This tests explicitely the filtering of a versioned object using Q objects.
        However, since this is done implicetly with every call to 'as_of', this test is redundant but is kept for
        explicit test coverage
        """
        t1 = get_utc_now()
        sleep(0.1)

        p1 = Player.objects.current.get(name__startswith='p1')
        self.team.player_set.remove(p1)

        p1 = Player.objects.current.get(name__startswith='p1')
        p1.name = 'p1.v2'
        p1.save()

        t2 = get_utc_now()
        sleep(0.1)

        t1_players = list(
            Player.objects.as_of(t1).filter(
                Q(name__startswith='p1')
                | Q(name__startswith='p2')).values_list('name', flat=True))
        self.assertEqual(2, len(t1_players))
        self.assertListEqual(sorted(t1_players), sorted(['p1.v1', 'p2.v1']))
예제 #8
0
    def test_creating_new_version_of_the_player(self):
        t1 = get_utc_now()
        sleep(0.1)

        p1 = self.p1.clone()
        p1.name = 'p1.v2'
        p1.save()

        sleep(0.1)
        t2 = get_utc_now()

        self.assertEqual(3, Player.objects.all().count())

        # at t1 there is no player named 'p1.v2'
        team = Team.objects.as_of(t1).first()
        self.assertEqual(2, team.player_set.count())
        for player in team.player_set.all():
            self.assertNotEqual(u'p1.v2', six.u(str(player.name)))

        # at t2 there must be a 2 players and on of them is named 'p1.v2'
        team = Team.objects.as_of(t2).first()
        self.assertEqual(2, team.player_set.count())

        if six.PY2:
            matches = itertools.ifilter(lambda x: x.name == 'p1.v2', team.player_set.all())
        if six.PY3:
            matches = filter(lambda x: x.name == 'p1.v2', team.player_set.all())
        self.assertEqual(1, len(list(matches)))
예제 #9
0
    def test_creating_new_version_of_parent_directory(self):
        t1 = get_utc_now()
        sleep(0.1)

        parentdir_v1 = Directory.objects.get(name__startswith='parent.v1')
        self.assertTrue(parentdir_v1.is_current)
        parentdir_v2 = parentdir_v1.clone()
        parentdir_v2.name = 'parent.v2'
        parentdir_v2.save()

        t2 = get_utc_now()

        # 1 parent dir, 2 subdirs, 2 new versions after linking then together
        # and 1 new version of the parent dir
        self.assertEqual(6, Directory.objects.all().count())

        self.assertTrue(parentdir_v2.is_current)

        # We didn't change anything to the subdirs so there must be 2 subdirs in
        # the parent at time t1...
        parentdir_at_t1 = Directory.objects.as_of(t1).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.count())

        # ... and at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t2.directory_set.count())
예제 #10
0
    def test_creating_new_version_of_the_team(self):
        t1 = get_utc_now()
        sleep(0.1)

        team = self.team.clone()
        team.name = 't.v2'
        team.save()

        t2 = get_utc_now()

        self.assertEqual(2, Team.objects.all().count())

        team = Team.objects.current.first()
        # Either we can test the version_end_date...
        self.assertIsNone(team.version_end_date)
        # ...or the is_current property
        self.assertTrue(team.is_current)

        # We didn't change anything to the players so there must be 2 players in
        # the team at time t1...
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.count())

        # ... and at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(2, team_at_t2.player_set.count())
예제 #11
0
    def setUp(self):
        billy = Pupil.objects.create(name='Billy', phone_number='123')
        erika = Pupil.objects.create(name='Erika', phone_number='456')

        ms_sue = Teacher.objects.create(name='Ms. Sue', domain='English')
        ms_klishina = Teacher.objects.create(name='Ms. Klishina', domain='Russian')

        mr_kazmirek = Teacher.objects.create(name='Mr. Kazmirek', domain='Math')
        ms_mayer = Teacher.objects.create(name='Ms. Mayer', domain='Chemistry')

        self.t0 = get_utc_now()
        sleep(0.1)

        billy.language_teachers.add(ms_sue)
        erika.science_teachers.add(mr_kazmirek, ms_mayer)

        self.t1 = get_utc_now()
        sleep(0.1)

        billy.language_teachers.add(ms_klishina)
        billy.language_teachers.remove(ms_sue)

        self.t2 = get_utc_now()
        sleep(0.1)

        erika.science_teachers.remove(ms_mayer)

        self.t3 = get_utc_now()
예제 #12
0
    def test_removing_and_then_adding_again_same_subdir(self):
        t1 = get_utc_now()
        sleep(0.1)

        subdir1_v1 = Directory.objects.current.get(name__startswith='subdir1')
        subdir1_v2 = subdir1_v1.clone()
        subdir1_v2.parent = None
        subdir1_v2.name = 'subdir1.v2'
        subdir1_v2.save()

        t2 = get_utc_now()
        sleep(0.1)

        current_parentdir = Directory.objects.current.get(name__startswith='parent')
        subdir1_v3 = subdir1_v2.clone()
        subdir1_v3.parent = current_parentdir
        subdir1_v3.name = 'subdir1.v3'
        subdir1_v3.save()

        t3 = get_utc_now()

        # there should be 2 directories in the parent directory at time t1
        parentdir_at_t1 = Directory.objects.as_of(t1).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.all().count())

        # there should be 1 directory in the parent directory at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).get(name__startswith='parent')
        self.assertEqual(1, parentdir_at_t2.directory_set.all().count())

        # there should be 2 directories in the parent directory at time t3
        parentdir_at_t3 = Directory.objects.as_of(t3).get(name__startswith='parent')
        self.assertEqual(2, parentdir_at_t3.directory_set.all().count())
예제 #13
0
    def test_adding_more_subdir(self):
        t1 = get_utc_now()
        sleep(0.1)

        current_parentdir = Directory.objects.current.get(name__startswith='parent')
        self.assertEqual(2, current_parentdir.directory_set.all().count())
        sleep(0.1)

        Directory.objects.create(name='subdir3.v1', parent=current_parentdir)
        t2 = get_utc_now()

        # there must not be 3 subdirectories in the parent directory, since current_parentdir holds the state
        # at t1 - prior to adding "subdir3"
        self.assertNotEqual(3, current_parentdir.directory_set.all().count())
        # If we wanted this comparision to be equal, we'd need to removed the 'as_of' timestamp within 'current_parentdir'
        # Let's do that:
        current_parentdir.as_of = None
        self.assertEqual(3, current_parentdir.directory_set.all().count())


        # there should be 2 directories in the parent directory at time t1
        parentdir_at_t1 = Directory.objects.as_of(t1).filter(name='parent.v1').first()
        self.assertEqual(2, parentdir_at_t1.directory_set.all().count())

        # there should be 3 directories in the parent directory at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).filter(name='parent.v1').first()
        self.assertEqual(3, parentdir_at_t2.directory_set.all().count())
예제 #14
0
    def test_creating_new_version_of_the_player(self):
        t1 = get_utc_now()
        sleep(0.1)

        p1 = self.p1.clone()
        p1.name = 'p1.v2'
        p1.save()

        sleep(0.1)
        t2 = get_utc_now()

        self.assertEqual(3, Player.objects.all().count())

        # at t1 there is no player named 'p1.v2'
        team = Team.objects.as_of(t1).first()
        self.assertEqual(2, team.player_set.count())
        for player in team.player_set.all():
            self.assertNotEqual(u'p1.v2', six.u(str(player.name)))

        # at t2 there must be a 2 players and on of them is named 'p1.v2'
        team = Team.objects.as_of(t2).first()
        self.assertEqual(2, team.player_set.count())

        if six.PY2:
            matches = itertools.ifilter(lambda x: x.name == 'p1.v2',
                                        team.player_set.all())
        if six.PY3:
            matches = filter(lambda x: x.name == 'p1.v2',
                             team.player_set.all())
        self.assertEqual(1, len(list(matches)))
예제 #15
0
    def test_creating_new_version_of_the_team(self):
        t1 = get_utc_now()
        sleep(0.1)

        team = self.team.clone()
        team.name = 't.v2'
        team.save()

        t2 = get_utc_now()

        self.assertEqual(2, Team.objects.all().count())

        team = Team.objects.current.first()
        # Either we can test the version_end_date...
        self.assertIsNone(team.version_end_date)
        # ...or the is_current property
        self.assertTrue(team.is_current)

        # We didn't change anything to the players so there must be 2 players in
        # the team at time t1...
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.count())

        # ... and at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(2, team_at_t2.player_set.count())
예제 #16
0
    def test_filtering_on_the_other_side_of_the_relation(self):
        t1 = get_utc_now()
        sleep(0.1)

        p2 = Player.objects.get(name='p2.v1')
        self.team.player_set.remove(p2)

        t2 = get_utc_now()
        sleep(0.1)

        p1 = Player.objects.get(name='p1.v1')
        self.team.player_set.remove(p1)

        t3 = get_utc_now()
        sleep(0.1)

        # Let's get those players back into the game!
        p1 = Player.objects.current.get(name='p1.v1')
        p2 = Player.objects.current.get(name='p2.v1')
        self.team.player_set.add(p1)
        self.team.player_set.add(p2)

        t4 = get_utc_now()

        self.assertEqual(1, Team.objects.all().count())
        self.assertEqual(1, Team.objects.as_of(t1).all().count())
        self.assertEqual(3, Player.objects.filter(name='p1.v1').all().count())
        self.assertEqual(3, Player.objects.filter(name='p2.v1').all().count())
        self.assertEqual(1, Player.objects.as_of(t1).filter(name='p1.v1').all().count())
        self.assertEqual(1, Player.objects.as_of(t1).filter(name='p2.v1').all().count())

        # at t1 there should be one team with two players
        p1 = Team.objects.as_of(t1).filter(player__name='p1.v1').propagate_querytime().first()
        self.assertIsNotNone(p1)
        p2 = Team.objects.as_of(t1).filter(player__name='p2.v1').propagate_querytime().first()
        self.assertIsNotNone(p2)

        # at t2 there should be one team with one single player called 'p1.v1'
        p1 = Team.objects.as_of(t2).filter(player__name='p1.v1').propagate_querytime().first()
        p2 = Team.objects.as_of(t2).filter(player__name='p2.v1').propagate_querytime().first()
        self.assertIsNotNone(p1)
        self.assertIsNone(p2)

        # at t3 there should be one team with no players
        p1 = Team.objects.as_of(t3).filter(player__name='p1.v1').propagate_querytime().first()
        p2 = Team.objects.as_of(t3).filter(player__name='p2.v1').propagate_querytime().first()
        self.assertIsNone(p1)
        self.assertIsNone(p2)

        # at t4 there should be one team with two players again!
        p1 = Team.objects.as_of(t4).filter(player__name='p1.v1').first()
        p2 = Team.objects.as_of(t4).filter(player__name='p2.v1').first()
        self.assertIsNotNone(p1)
        self.assertIsNotNone(p2)
예제 #17
0
파일: base.py 프로젝트: cygery/pretix
    def clone_shallow(self, forced_version_date=None):
        """
        This behaves like clone(), but misses all the Many2Many-relation-handling. This is
        a performance optimization for cases in which we have to handle the Many2Many relations
        by hand anyways.
        """
        if not self.pk:  # NOQA
            raise ValueError('Instance must be saved before it can be cloned')

        if self.version_end_date:  # NOQA
            raise ValueError(
                'This is a historical item and can not be cloned.')

        if forced_version_date:  # NOQA
            if not self.version_start_date <= forced_version_date <= get_utc_now(
            ):
                raise ValueError(
                    'The clone date must be between the version start date and now.'
                )
        else:
            forced_version_date = get_utc_now()

        earlier_version = self

        later_version = copy.copy(earlier_version)
        later_version.version_end_date = None
        later_version.version_start_date = forced_version_date

        # set earlier_version's ID to a new UUID so the clone (later_version) can
        # get the old one -- this allows 'head' to always have the original
        # id allowing us to get at all historic foreign key relationships
        earlier_version.id = six.u(str(uuid.uuid4()))
        earlier_version.version_end_date = forced_version_date
        earlier_version.save()

        for field in earlier_version._meta.many_to_many:
            earlier_version.clone_relations_shallow(later_version,
                                                    field.attname,
                                                    forced_version_date)

        if hasattr(earlier_version._meta, 'many_to_many_related'):
            for rel in earlier_version._meta.many_to_many_related:
                earlier_version.clone_relations_shallow(
                    later_version, rel.via_field_name, forced_version_date)

        later_version.save()

        return later_version
예제 #18
0
    def test_adding_more_player_to_the_team(self):
        t1 = get_utc_now()
        sleep(0.1)

        self.assertEqual(2, self.team.player_set.all().count())

        new_player = Player.objects.create(name='p3.v1', team=self.team)
        t2 = get_utc_now()

        # there should be 3 players now in the team
        self.assertEqual(3, self.team.player_set.all().count())

        # there should be 2 players in the team at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 3 players in the team at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(3, team_at_t2.player_set.all().count())
예제 #19
0
    def test_adding_more_player_to_the_team(self):
        t1 = get_utc_now()
        sleep(0.1)

        self.assertEqual(2, self.team.player_set.all().count())

        new_player = Player.objects.create(name='p3.v1', team=self.team)
        t2 = get_utc_now()

        # there should be 3 players now in the team
        self.assertEqual(3, self.team.player_set.all().count())

        # there should be 2 players in the team at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 3 players in the team at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(3, team_at_t2.player_set.all().count())
예제 #20
0
파일: base.py 프로젝트: cygery/pretix
    def clone_shallow(self, forced_version_date=None):
        """
        This behaves like clone(), but misses all the Many2Many-relation-handling. This is
        a performance optimization for cases in which we have to handle the Many2Many relations
        by hand anyways.
        """
        if not self.pk:  # NOQA
            raise ValueError('Instance must be saved before it can be cloned')

        if self.version_end_date:  # NOQA
            raise ValueError('This is a historical item and can not be cloned.')

        if forced_version_date:  # NOQA
            if not self.version_start_date <= forced_version_date <= get_utc_now():
                raise ValueError('The clone date must be between the version start date and now.')
        else:
            forced_version_date = get_utc_now()

        earlier_version = self

        later_version = copy.copy(earlier_version)
        later_version.version_end_date = None
        later_version.version_start_date = forced_version_date

        # set earlier_version's ID to a new UUID so the clone (later_version) can
        # get the old one -- this allows 'head' to always have the original
        # id allowing us to get at all historic foreign key relationships
        earlier_version.id = six.u(str(uuid.uuid4()))
        earlier_version.version_end_date = forced_version_date
        earlier_version.save()

        for field in earlier_version._meta.many_to_many:
            earlier_version.clone_relations_shallow(later_version, field.attname, forced_version_date)

        if hasattr(earlier_version._meta, 'many_to_many_related'):
            for rel in earlier_version._meta.many_to_many_related:
                earlier_version.clone_relations_shallow(later_version, rel.via_field_name, forced_version_date)

        later_version.save()

        return later_version
예제 #21
0
    def setUp(self):
        c1 = C1(name='c1.v1')
        c2 = C2(name='c2.v1')
        c3 = C3(name='c3.v1')

        c1.save()
        c2.save()
        c3.save()

        c2.c3s.add(c3)
        c1.c2s.add(c2)

        self.t1 = get_utc_now()
        sleep(0.2)

        c3a = C3(name='c3a.v1')
        c3a.save()
        c2.c3s.add(c3a)

        sleep(0.2)
        self.t2 = get_utc_now()
예제 #22
0
def set_up_one_object_with_3_versions():
    b = B.objects.create(name='v1')

    sleep(0.1)
    t1 = get_utc_now()

    b = b.clone()
    b.name = 'v2'
    b.save()

    sleep(0.1)
    t2 = get_utc_now()

    b = b.clone()
    b.name = 'v3'
    b.save()

    sleep(0.1)
    t3 = get_utc_now()

    return b, t1, t2, t3
예제 #23
0
def set_up_one_object_with_3_versions():
    b = B.objects.create(name='v1')

    sleep(0.1)
    t1 = get_utc_now()

    b = b.clone()
    b.name = 'v2'
    b.save()

    sleep(0.1)
    t2 = get_utc_now()

    b = b.clone()
    b.name = 'v3'
    b.save()

    sleep(0.1)
    t3 = get_utc_now()

    return b, t1, t2, t3
예제 #24
0
    def test_removing_and_then_adding_again_same_player_on_related_object(
            self):
        t1 = get_utc_now()
        sleep(0.1)

        self.team.player_set.remove(self.p1)

        # Remember: self.p1 was cloned while removing and is not current anymore!!
        # This property has to be documented, since it's critical for developers!
        # At this time, there is no mean to replace the contents of self.p1 within the
        # remove method
        p1 = Player.objects.current.get(name__startswith='p1')
        self.assertNotEqual(p1, self.p1)
        p1.name = 'p1.v2'
        p1.save()
        self.p1 = p1

        t2 = get_utc_now()
        sleep(0.1)

        self.team.player_set.add(self.p1)

        # Same thing here! Don't rely on an added value!
        p1 = Player.objects.current.get(name__startswith='p1')
        p1.name = 'p1.v3'
        p1.save()

        t3 = get_utc_now()

        # there should be 2 players in the team if we put ourselves back at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 1 players in the team if we put ourselves back at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(1, team_at_t2.player_set.all().count())

        # there should be 2 players in the team if we put ourselves back at time t3
        team_at_t3 = Team.objects.as_of(t3).first()
        self.assertEqual(2, team_at_t3.player_set.all().count())
예제 #25
0
    def test_removing_and_then_adding_again_same_player_on_related_object(self):
        t1 = get_utc_now()
        sleep(0.1)

        self.team.player_set.remove(self.p1)

        # Remember: self.p1 was cloned while removing and is not current anymore!!
        # This property has to be documented, since it's critical for developers!
        # At this time, there is no mean to replace the contents of self.p1 within the
        # remove method
        p1 = Player.objects.current.get(name__startswith='p1')
        self.assertNotEqual(p1, self.p1)
        p1.name = 'p1.v2'
        p1.save()
        self.p1 = p1

        t2 = get_utc_now()
        sleep(0.1)

        self.team.player_set.add(self.p1)

        # Same thing here! Don't rely on an added value!
        p1 = Player.objects.current.get(name__startswith='p1')
        p1.name = 'p1.v3'
        p1.save()

        t3 = get_utc_now()

        # there should be 2 players in the team if we put ourselves back at time t1
        team_at_t1 = Team.objects.as_of(t1).first()
        self.assertEqual(2, team_at_t1.player_set.all().count())

        # there should be 1 players in the team if we put ourselves back at time t2
        team_at_t2 = Team.objects.as_of(t2).first()
        self.assertEqual(1, team_at_t2.player_set.all().count())

        # there should be 2 players in the team if we put ourselves back at time t3
        team_at_t3 = Team.objects.as_of(t3).first()
        self.assertEqual(2, team_at_t3.player_set.all().count())
예제 #26
0
    def test_creating_new_version_of_the_subdir(self):
        t1 = get_utc_now()

        subdir1_v1 = Directory.objects.current.get(name__startswith='subdir1')
        subdir1_v2 = subdir1_v1.clone()
        subdir1_v2.name = 'subdir1.v2'
        subdir1_v2.save()

        sleep(0.1)
        t2 = get_utc_now()

        # Count all Directory instance versions:
        # 3 initial versions + 2 subdirs added to parentdir (implies a clone) + 1 subdir1 that was explicitely cloned = 6
        self.assertEqual(6, Directory.objects.all().count())

        # at t1 there is no directory named 'subdir1.v2'
        parentdir_at_t1 = Directory.objects.as_of(t1).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.count())

        for subdir in parentdir_at_t1.directory_set.all():
            self.assertNotEqual('subdir1.v2', subdir.name)

        # at t2 there must be 2 directories and ...
        parentdir_at_t2 = Directory.objects.as_of(t2).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t2.directory_set.count())

        # ... and one of then is named 'subdir1.v2'
        if six.PY2:
            matches = itertools.ifilter(lambda x: x.name == 'subdir1.v2',
                                        parentdir_at_t2.directory_set.all())
        if six.PY3:
            matches = filter(lambda x: x.name == 'subdir1.v2',
                             parentdir_at_t2.directory_set.all())
        self.assertEqual(1, len(list(matches)))
예제 #27
0
    def test_simple_filter_using_q_objects(self):
        """
        This tests explicitely the filtering of a versioned object using Q objects.
        However, since this is done implicetly with every call to 'as_of', this test is redundant but is kept for
        explicit test coverage
        """
        t1 = get_utc_now()
        sleep(0.1)

        p1 = Player.objects.current.get(name__startswith='p1')
        self.team.player_set.remove(p1)

        p1 = Player.objects.current.get(name__startswith='p1')
        p1.name = 'p1.v2'
        p1.save()

        t2 = get_utc_now()
        sleep(0.1)

        t1_players = list(
            Player.objects.as_of(t1).filter(Q(name__startswith='p1') | Q(name__startswith='p2')).values_list('name',
                                                                                                             flat=True))
        self.assertEqual(2, len(t1_players))
        self.assertListEqual(sorted(t1_players), sorted(['p1.v1', 'p2.v1']))
예제 #28
0
    def test_removing_and_then_adding_again_same_subdir(self):
        t1 = get_utc_now()
        sleep(0.1)

        subdir1_v1 = Directory.objects.current.get(name__startswith='subdir1')
        subdir1_v2 = subdir1_v1.clone()
        subdir1_v2.parent = None
        subdir1_v2.name = 'subdir1.v2'
        subdir1_v2.save()

        t2 = get_utc_now()
        sleep(0.1)

        current_parentdir = Directory.objects.current.get(
            name__startswith='parent')
        subdir1_v3 = subdir1_v2.clone()
        subdir1_v3.parent = current_parentdir
        subdir1_v3.name = 'subdir1.v3'
        subdir1_v3.save()

        t3 = get_utc_now()

        # there should be 2 directories in the parent directory at time t1
        parentdir_at_t1 = Directory.objects.as_of(t1).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t1.directory_set.all().count())

        # there should be 1 directory in the parent directory at time t2
        parentdir_at_t2 = Directory.objects.as_of(t2).get(
            name__startswith='parent')
        self.assertEqual(1, parentdir_at_t2.directory_set.all().count())

        # there should be 2 directories in the parent directory at time t3
        parentdir_at_t3 = Directory.objects.as_of(t3).get(
            name__startswith='parent')
        self.assertEqual(2, parentdir_at_t3.directory_set.all().count())
예제 #29
0
    def setUp(self):
        c1 = C1(name='c1.v1')
        c2 = C2(name='c2.v1')
        c3 = C3(name='c3.v1')

        c1.save()
        c2.save()
        c3.save()

        self.t0 = get_utc_now()
        sleep(0.1)

        c2.c3s.add(c3)
        c1.c2s.add(c2)

        self.t1 = get_utc_now()
        sleep(0.1)

        c3a = C3(name='c3a.v1')
        c3a.save()
        c2.c3s.add(c3a)

        sleep(0.1)
        self.t2 = get_utc_now()
예제 #30
0
    def setUp(self):
        # -------------- t0:
        mr_biggs = Professor.objects.create(name='Mr. Biggs', address='123 Mainstreet, Somewhere',
                                            phone_number='123')
        ms_piggy = Professor.objects.create(name='Ms. Piggy', address='82 Leicester Street, London',
                                            phone_number='987')

        gym = Classroom.objects.create(name='Sports room', building='The big one over there')
        phylo = Classroom.objects.create(name='Philosophy lectures', building='The old one')

        annika = Student.objects.create(name='Annika')
        annika.professors.add(mr_biggs)
        annika.professors.add(ms_piggy)
        annika.classrooms.add(phylo)
        annika.classrooms.add(gym)

        benny = Student.objects.create(name='Benny')
        benny.professors.add(mr_biggs)
        benny.classrooms.add(gym)

        sophie = Student.objects.create(name='Sophie')
        # Sophie doesn't study at that school yet, but is already subscribed

        self.t0 = get_utc_now()
        sleep(0.1)

        # -------------- t1:
        # Mr. Biggs moves to Berne
        mr_biggs = mr_biggs.clone()
        mr_biggs.address = 'Thunplatz, Bern'
        mr_biggs.save()

        # Mr. Evans gets hired
        mr_evans = Professor.objects.create(name='Mr. Evans', address='lives in a camper',
                                            phone_number='456')

        # A lab gets built
        lab = Classroom.objects.create(name='Physics and stuff', building='The old one')

        self.t1 = get_utc_now()
        sleep(0.1)

        # -------------- t2:
        # Mr. Evans starts to teach sophie in the lab
        mr_evans.students.add(sophie)
        lab.students.add(sophie)

        self.t2 = get_utc_now()
        sleep(0.1)

        # -------------- t3:
        # Annika is joining Sophie
        annika.professors.add(mr_evans)
        annika.classrooms.add(lab)

        self.t3 = get_utc_now()
        sleep(0.1)

        # -------------- t4:
        # Benny cuts that sh*t
        benny.professors.remove(mr_biggs)

        self.t4 = get_utc_now()
예제 #31
0
    def test_filtering_on_the_other_side_of_the_relation(self):
        t1 = get_utc_now()
        sleep(0.1)

        p2 = Player.objects.get(name='p2.v1')
        self.team.player_set.remove(p2)

        t2 = get_utc_now()
        sleep(0.1)

        p1 = Player.objects.get(name='p1.v1')
        self.team.player_set.remove(p1)

        t3 = get_utc_now()
        sleep(0.1)

        # Let's get those players back into the game!
        p1 = Player.objects.current.get(name='p1.v1')
        p2 = Player.objects.current.get(name='p2.v1')
        self.team.player_set.add(p1)
        self.team.player_set.add(p2)

        t4 = get_utc_now()

        self.assertEqual(1, Team.objects.all().count())
        self.assertEqual(1, Team.objects.as_of(t1).all().count())
        self.assertEqual(3, Player.objects.filter(name='p1.v1').all().count())
        self.assertEqual(3, Player.objects.filter(name='p2.v1').all().count())
        self.assertEqual(
            1,
            Player.objects.as_of(t1).filter(name='p1.v1').all().count())
        self.assertEqual(
            1,
            Player.objects.as_of(t1).filter(name='p2.v1').all().count())

        # at t1 there should be one team with two players
        p1 = Team.objects.as_of(t1).filter(
            player__name='p1.v1').propagate_querytime().first()
        self.assertIsNotNone(p1)
        p2 = Team.objects.as_of(t1).filter(
            player__name='p2.v1').propagate_querytime().first()
        self.assertIsNotNone(p2)

        # at t2 there should be one team with one single player called 'p1.v1'
        p1 = Team.objects.as_of(t2).filter(
            player__name='p1.v1').propagate_querytime().first()
        p2 = Team.objects.as_of(t2).filter(
            player__name='p2.v1').propagate_querytime().first()
        self.assertIsNotNone(p1)
        self.assertIsNone(p2)

        # at t3 there should be one team with no players
        p1 = Team.objects.as_of(t3).filter(
            player__name='p1.v1').propagate_querytime().first()
        p2 = Team.objects.as_of(t3).filter(
            player__name='p2.v1').propagate_querytime().first()
        self.assertIsNone(p1)
        self.assertIsNone(p2)

        # at t4 there should be one team with two players again!
        p1 = Team.objects.as_of(t4).filter(player__name='p1.v1').first()
        p2 = Team.objects.as_of(t4).filter(player__name='p2.v1').first()
        self.assertIsNotNone(p1)
        self.assertIsNotNone(p2)
예제 #32
0
    def setUp(self):
        # -------------- t0:
        mr_biggs = Professor.objects.create(
            name='Mr. Biggs',
            address='123 Mainstreet, Somewhere',
            phone_number='123')
        ms_piggy = Professor.objects.create(
            name='Ms. Piggy',
            address='82 Leicester Street, London',
            phone_number='987')

        gym = Classroom.objects.create(name='Sports room',
                                       building='The big one over there')
        phylo = Classroom.objects.create(name='Philosophy lectures',
                                         building='The old one')

        annika = Student.objects.create(name='Annika')
        annika.professors.add(mr_biggs)
        annika.professors.add(ms_piggy)
        annika.classrooms.add(phylo)
        annika.classrooms.add(gym)

        benny = Student.objects.create(name='Benny')
        benny.professors.add(mr_biggs)
        benny.classrooms.add(gym)

        sophie = Student.objects.create(name='Sophie')
        # Sophie doesn't study at that school yet, but is already subscribed

        self.t0 = get_utc_now()
        sleep(0.1)

        # -------------- t1:
        # Mr. Biggs moves to Berne
        mr_biggs = mr_biggs.clone()
        mr_biggs.address = 'Thunplatz, Bern'
        mr_biggs.save()

        # Mr. Evans gets hired
        mr_evans = Professor.objects.create(name='Mr. Evans',
                                            address='lives in a camper',
                                            phone_number='456')

        # A lab gets built
        lab = Classroom.objects.create(name='Physics and stuff',
                                       building='The old one')

        self.t1 = get_utc_now()
        sleep(0.1)

        # -------------- t2:
        # Mr. Evans starts to teach sophie in the lab
        mr_evans.students.add(sophie)
        lab.students.add(sophie)

        self.t2 = get_utc_now()
        sleep(0.1)

        # -------------- t3:
        # Annika is joining Sophie
        annika.professors.add(mr_evans)
        annika.classrooms.add(lab)

        self.t3 = get_utc_now()
        sleep(0.1)

        # -------------- t4:
        # Benny cuts that sh*t
        benny.professors.remove(mr_biggs)

        self.t4 = get_utc_now()