コード例 #1
0
ファイル: tests.py プロジェクト: advishnuprasad/protean
    def test_uow_can_be_initiated_explicitly(self, test_domain):
        uow = UnitOfWork()
        assert uow is not None
        assert uow.in_progress is False

        uow.start()
        assert uow.in_progress is True
コード例 #2
0
def test_tracking_aggregate_on_add(test_domain):
    uow = UnitOfWork()
    uow.start()

    test_domain.repository_for(User).add(User(name="John Doe"))

    assert len(uow._seen) == 1
コード例 #3
0
ファイル: tests.py プロジェクト: advishnuprasad/protean
    def test_that_uow_can_be_started_manually(self, test_domain):
        uow = UnitOfWork()

        uow.start()
        uow.commit()  # `commit` should not raise exception

        uow.start()
        uow.rollback()  # `rollback` should not raise exception
コード例 #4
0
def test_tracking_aggregate_on_filtering(test_domain):
    test_domain.repository_for(User).add(User(id=12, name="John Doe"))
    test_domain.repository_for(User).add(User(id=13, name="Jane Doe"))

    uow = UnitOfWork()
    uow.start()

    test_domain.repository_for(User)._dao.query.filter(name__contains="Doe").all()

    assert len(uow._seen) == 2
    assert all(isinstance(item, User) for item in uow._seen)
コード例 #5
0
def test_tracking_aggregate_on_get(test_domain):
    test_domain.repository_for(User).add(User(id=12, name="John Doe"))

    uow = UnitOfWork()
    uow.start()

    test_domain.repository_for(User).get(12)

    assert len(uow._seen) == 1
    seen_item = next(iter(uow._seen))
    assert isinstance(seen_item, User)
コード例 #6
0
def test_tracking_aggregate_on_update(test_domain):
    test_domain.repository_for(User).add(User(id=12, name="John Doe"))

    user = test_domain.repository_for(User).get(12)

    uow = UnitOfWork()
    uow.start()

    user.name = "Name Changed"
    test_domain.repository_for(User).add(user)

    assert len(uow._seen) == 1
    seen_item = next(iter(uow._seen))
    assert seen_item.name == "Name Changed"
コード例 #7
0
    def test_changed_objects_are_committed_as_part_of_one_transaction(self, test_domain):
        # Add a Person the database
        repo = test_domain.repository_for(Person)
        person_to_be_updated = self.persisted_person(test_domain)
        person_to_be_deleted = self.persisted_person(test_domain)
        repo.add(person_to_be_updated)
        repo.add(person_to_be_deleted)

        person_dao = test_domain.get_dao(Person)

        # Initiate a UnitOfWork Session
        with UnitOfWork():
            repo_with_uow = test_domain.repository_for(Person)

            # Create a new person object to be added
            person_to_be_added = Person(first_name='John', last_name='Doe')
            repo_with_uow.add(person_to_be_added)

            # Update an existing Person record
            person_to_be_updated.last_name = 'FooBar'
            repo_with_uow.add(person_to_be_updated)

            # Remove an existing Person record
            repo_with_uow.remove(person_to_be_deleted)

            # Test that the underlying database is untouched
            assert len(person_dao.query.all().items) == 2
            assert person_dao.outside_uow().get(person_to_be_updated.id).last_name != 'FooBar'
            assert person_dao.get(person_to_be_deleted.id) is not None

        assert len(person_dao.query.all().items) == 2
        assert person_dao.get(person_to_be_added.id) is not None
        assert person_dao.get(person_to_be_updated.id).last_name == 'FooBar'
        with pytest.raises(ObjectNotFoundError):
            person_dao.get(person_to_be_deleted.id)
コード例 #8
0
    def add(cls, command: PersonCommand):
        with UnitOfWork():
            newcomer = Person.add_newcomer(command.to_dict())

            person_repo = current_domain.repository_for(Person)
            person_repo.add(newcomer)

        return newcomer
コード例 #9
0
def test_that_events_are_empty_after_uow():
    user = User(name="John Doe", email="*****@*****.**")
    user.change_name("Jane Doe")
    user.activate()

    with UnitOfWork():
        user_repo = current_domain.repository_for(User)
        user_repo.add(user)

    assert len(user._events) == 0
コード例 #10
0
    def test_session_is_destroyed_after_rollback(self, test_domain):
        uow = UnitOfWork()
        uow.start()

        uow.rollback()
        assert uow._sessions == {}
        assert uow.in_progress is False
コード例 #11
0
ファイル: tests.py プロジェクト: advishnuprasad/protean
    def test_that_uow_throws_exception_on_commit_or_rollback_without_being_started(
            self, test_domain):
        uow = UnitOfWork()

        with pytest.raises(InvalidOperationError):
            uow.commit()

        with pytest.raises(InvalidOperationError):
            uow.rollback()
コード例 #12
0
    def test_that_an_entity_can_be_added_within_uow(self, test_domain, persisted_post):
        repo = test_domain.repository_for(Post)

        with UnitOfWork():
            comment = Comment(content='So La Ti Do')
            persisted_post.comments.add(comment)

            repo = test_domain.repository_for(Post)
            repo.add(persisted_post)

            # FIXME Refactor `outside_uow` to be a global thread variable
            # post_dao = test_domain.get_dao(Post)
            # assert len(post_dao.outside_uow().get(persisted_post.id).comments) == 0

        post = repo.get(persisted_post.id)
        assert len(post.comments) == 1
        assert post.comments[0].content == 'So La Ti Do'
コード例 #13
0
    def test_deleted_objects_are_committed_as_part_of_one_transaction(self, test_domain):
        # Add a Person the database
        repo = test_domain.repository_for(Person)
        person_to_be_added = self.persisted_person(test_domain)
        repo.add(person_to_be_added)

        person_dao = test_domain.get_dao(Person)

        # Initiate a UnitOfWork Session
        with UnitOfWork():
            repo = test_domain.repository_for(Person)
            persisted_person = repo.get(person_to_be_added.id)
            repo.remove(persisted_person)

            # Test that the underlying database is untouched
            assert len(person_dao.outside_uow().query.all().items) == 1

        assert len(person_dao.query.all().items) == 0
コード例 #14
0
    def test_new_objects_are_committed_as_part_of_one_transaction(self, test_domain):
        # Add a Person the database
        repo = test_domain.repository_for(Person)
        repo.add(self.persisted_person(test_domain))

        person_dao = test_domain.get_dao(Person)

        # Initiate a UnitOfWork Session
        with UnitOfWork():
            repo = test_domain.repository_for(Person)
            person2 = Person(first_name='Jane', last_name='Doe')
            repo.add(person2)

            # Test that the underlying database is untouched

            assert len(person_dao.outside_uow().query.all().items) == 1

        assert len(person_dao.query.all().items) == 2
コード例 #15
0
    def test_that_an_entity_can_be_removed_within_uow(self, test_domain, persisted_post):
        comment = Comment(content='So La Ti Do')
        persisted_post.comments.add(comment)

        repo = test_domain.repository_for(Post)
        repo.add(persisted_post)

        with UnitOfWork():
            comment = persisted_post.comments[0]
            persisted_post.comments.remove(comment)

            repo = test_domain.repository_for(Post)
            repo.add(persisted_post)

            # FIXME Refactor `outside_uow` to be a global thread variable
            # assert comment.id in uow.changes_to_be_committed['default']['REMOVED']

        post = repo.get(persisted_post.id)
        assert len(post.comments) == 0
コード例 #16
0
    def test_updated_objects_are_committed_as_part_of_one_transaction(self, test_domain):
        # Add a Person the database
        repo = test_domain.repository_for(Person)
        person = Person(first_name='John', last_name='Doe')
        repo.add(person)

        person_dao = test_domain.get_dao(Person)

        # Initiate a UnitOfWork Session
        with UnitOfWork():
            repo = test_domain.repository_for(Person)
            persisted_person = repo.get(person.id)

            persisted_person.last_name = 'Dane'
            repo.add(persisted_person)

            # Test that the underlying database is untouched
            assert person_dao.outside_uow().find_by(id=person.id).last_name == 'Doe'

        assert person_dao.get(person.id).last_name == 'Dane'
コード例 #17
0
    def test_that_an_entity_can_be_updated_within_uow(self, test_domain, persisted_post):
        comment = Comment(content='So La Ti Do')
        persisted_post.comments.add(comment)

        repo = test_domain.repository_for(Post)
        repo.add(persisted_post)

        post = repo.get(persisted_post.id)
        assert post.comments[0].content == 'So La Ti Do'

        with UnitOfWork():
            comment = persisted_post.comments[0]
            comment.content = ('Pa Da Ni Sa')
            persisted_post.comments.add(comment)

            repo = test_domain.repository_for(Post)
            repo.add(persisted_post)

            # FIXME Refactor `outside_uow` to be a global thread variable
            # assert comment.id in uow.changes_to_be_committed['default']['UPDATED']

        post = repo.get(persisted_post.id)
        assert post.comments[0].content == 'Pa Da Ni Sa'
コード例 #18
0
    def test_all_changes_are_discard_on_rollback(self, test_domain):
        repo = test_domain.repository_for(Person)
        person_to_be_updated = self.persisted_person(test_domain)
        person_to_be_deleted = self.persisted_person(test_domain)
        repo.add(person_to_be_updated)
        repo.add(person_to_be_deleted)

        person_dao = test_domain.get_dao(Person)

        # Initiate a UnitOfWork Session
        uow = UnitOfWork()
        uow.start()

        repo_with_uow = test_domain.repository_for(Person)

        # Create a new person object to be added
        person_to_be_added = Person(first_name="John", last_name="Doe")
        repo_with_uow.add(person_to_be_added)

        # Update an existing Person record
        person_to_be_updated.last_name = "FooBar"
        repo_with_uow.add(person_to_be_updated)

        # Remove an existing Person record
        repo_with_uow.remove(person_to_be_deleted)

        # Test that the underlying database is untouched
        assert len(person_dao.outside_uow().query.all().items) == 2
        assert (person_dao.outside_uow().get(person_to_be_updated.id).last_name
                != "FooBar")
        assert person_dao.outside_uow().get(
            person_to_be_deleted.id) is not None

        uow.rollback()

        assert uow.in_progress is False
        assert len(person_dao.query.all().items) == 2
        assert person_dao.get(person_to_be_updated.id).last_name != "FooBar"
        assert person_dao.get(person_to_be_deleted.id) is not None
コード例 #19
0
ファイル: mixins.py プロジェクト: proteanhq/protean
 def wrapper(instance, target_obj):
     # Wrap function call within a UoW
     with UnitOfWork():
         fn(instance, target_obj)
コード例 #20
0
ファイル: tests.py プロジェクト: advishnuprasad/protean
 def test_uow_can_be_initiated_with_context_manager(self, test_domain):
     with UnitOfWork() as uow:
         assert uow is not None
         assert uow.in_progress is True