Update in-memory repositories with latest changes from ordinary repos…

…itories

pybossa/repositories/blog_repository.py

@@ -95,8 +95,11 @@ def get_by(self, **attributes):
         posts = filter(lambda post: reduce(lambda y, z: y and getattr(post, z) == attributes[z], attributes.keys(), True), self.store.values())
         return None if len(posts) == 0 else posts.pop()
 
-    def filter_by(self, **filters):
-        return filter(lambda post: reduce(lambda y, z: y and getattr(post, z) == filters[z], filters.keys(), True), self.store.values())
+    def filter_by(self, limit=None, offset=0, **filters):
+        blogposts = filter(lambda post: reduce(lambda y, z: y and getattr(post, z) == filters[z], filters.keys(), True), self.store.values())
+        blogposts = sorted(blogposts, key=lambda item: item.id)
+        blogposts = blogposts[offset:] if limit is None else blogposts[offset:offset+limit]
+        return blogposts
 
     def save(self, blogpost):
         self._validate_can_be('saved', blogpost)

pybossa/repositories/project_repository.py

@@ -159,8 +159,11 @@ def get_by(self, **attributes):
     def get_all(self):
         return self.store.values()
 
-    def filter_by(self, **filters):
-        return filter(lambda project: reduce(lambda y, z: y and getattr(project, z) == filters[z], filters.keys(), True), self.store.values())
+    def filter_by(self, limit=None, offset=0, **filters):
+        projects = filter(lambda project: reduce(lambda y, z: y and getattr(project, z) == filters[z], filters.keys(), True), self.store.values())
+        projects = sorted(projects, key=lambda item: item.id)
+        projects = projects[offset:] if limit is None else projects[offset:offset+limit]
+        return projects
 
     def save(self, project):
         self._validate_can_be('saved', project)
@@ -172,8 +175,15 @@ def update(self, project):
         self._validate_can_be('updated', project)
         self.store[project.id] = project
 
-    def delete(self, project):
+    def delete(self, project, task_repo=None, blog_repo=None):
         self._validate_can_be('deleted', project)
+        if task_repo is not None:
+            tasks = task_repo.filter_tasks_by(app_id=project.id)
+            task_repo.delete_all(tasks)
+        if blog_repo is not None:
+            blogposts = blog_repo.filter_by(app_id=project.id)
+            for post in blogposts:
+                blog_repo.delete(post)
         del self.store[project.id]
 
 
@@ -190,8 +200,11 @@ def get_category_by(self, **attributes):
     def get_all_categories(self):
         return self.category_store.values()
 
-    def filter_categories_by(self, **filters):
-        return filter(lambda category: reduce(lambda y, z: y and getattr(category, z) == filters[z], filters.keys(), True), self.category_store.values())
+    def filter_categories_by(self, limit=None, offset=0, **filters):
+        cats = filter(lambda category: reduce(lambda y, z: y and getattr(category, z) == filters[z], filters.keys(), True), self.category_store.values())
+        cats = sorted(cats, key=lambda item: item.id)
+        cats = cats[offset:] if limit is None else cats[offset:offset+limit]
+        return cats
 
     def save_category(self, category):
         self._validate_can_be('saved as a Category', category, klass=Category)

pybossa/repositories/task_repository.py

@@ -165,8 +165,10 @@ def get_task_by(self, **attributes):
         tasks = filter(lambda task: reduce(lambda y, z: y and getattr(task, z) == attributes[z], attributes.keys(), True), self.task_store.values())
         return None if len(tasks) == 0 else tasks.pop()
 
-    def filter_tasks_by(self, yielded=False, **filters):
+    def filter_tasks_by(self, limit=None, offset=0, yielded=False, **filters):
         tasks = filter(lambda task: reduce(lambda y, z: y and getattr(task, z) == filters[z], filters.keys(), True), self.task_store.values())
+        tasks = sorted(tasks, key=lambda item: item.id)
+        tasks = tasks[offset:] if limit is None else tasks[offset:offset+limit]
         if yielded:
             return (tr for tr in tasks)
         return tasks
@@ -183,8 +185,10 @@ def get_task_run_by(self, **attributes):
         taskruns = filter(lambda taskrun: reduce(lambda y, z: y and getattr(taskrun, z) == attributes[z], attributes.keys(), True), self.taskrun_store.values())
         return None if len(taskruns) == 0 else taskruns.pop()
 
-    def filter_task_runs_by(self, yielded=False, **filters):
+    def filter_task_runs_by(self, limit=None, offset=0, yielded=False, **filters):
         taskruns = filter(lambda taskrun: reduce(lambda y, z: y and getattr(taskrun, z) == filters[z], filters.keys(), True), self.taskrun_store.values())
+        taskruns = sorted(taskruns, key=lambda item: item.id)
+        taskruns = taskruns[offset:] if limit is None else taskruns[offset:offset+limit]
         if yielded:
             return (tr for tr in taskruns)
         return taskruns
@@ -212,6 +216,8 @@ def update(self, element):
     def delete(self, element):
         self._validate_can_be('deleted', element)
         if isinstance(element, Task):
+            taskruns = self.filter_task_runs_by(task_id=element.id)
+            self.delete_all(taskruns)
             del self.task_store[element.id]
         if isinstance(element, TaskRun):
             del self.taskrun_store[element.id]

pybossa/repositories/user_repository.py

@@ -113,8 +113,11 @@ def get_by(self, **attributes):
     def get_all(self):
         return self.store.values()
 
-    def filter_by(self, **filters):
-        return filter(lambda user: reduce(lambda y, z: y and getattr(user, z) == filters[z], filters.keys(), True), self.store.values())
+    def filter_by(self, limit=None, offset=0, **filters):
+        users = filter(lambda user: reduce(lambda y, z: y and getattr(user, z) == filters[z], filters.keys(), True), self.store.values())
+        users = sorted(users, key=lambda item: item.id)
+        users = users[offset:] if limit is None else users[offset:offset+limit]
+        return users
 
     def search_by_name(self, keyword):
         if len(keyword) == 0:

test/test_repository/test_blog_repository.py

@@ -96,7 +96,7 @@ def test_filter_by_one_condition(self):
         assert should_be_missing not in retrieved_blogposts, retrieved_blogposts
 
 
-    def test_filter_tasks_limit_offset(self):
+    def test_filter_by_limit_offset(self):
         """Test that filter_by supports limit and offset options"""
 
         BlogpostFactory.create_batch(4)
@@ -289,6 +289,21 @@ def test_filter_by_multiple_conditions(self):
         assert blogpost in retrieved_blogposts, retrieved_blogposts
 
 
+    def test_filter_by_limit_offset(self):
+        """Test that filter_by supports limit and offset options"""
+
+        BlogpostFactoryMemory.create_batch(4)
+        all_blogposts = self.blog_repo.filter_by()
+
+        first_two = self.blog_repo.filter_by(limit=2)
+        last_two = self.blog_repo.filter_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_blogposts[:2]
+        assert last_two == all_blogposts[2:]
+
+
     def test_save(self):
         """Test save persist the blogpost"""
 

test/test_repository/test_project_repository.py

@@ -142,7 +142,7 @@ def test_filter_by_multiple_conditions(self):
         assert project in retrieved_projects, retrieved_projects
 
 
-    def test_filter_tasks_limit_offset(self):
+    def test_filter_by_limit_offset(self):
         """Test that filter_by supports limit and offset options"""
 
         AppFactory.create_batch(4)
@@ -342,7 +342,7 @@ def test_filter_categories_by_one_condition(self):
         assert should_be_missing not in retrieved_categories, retrieved_categories
 
 
-    def test_filter_tasks_limit_offset(self):
+    def test_filter_category_by_limit_offset(self):
         """Test that filter_categories_by supports limit and offset options"""
 
         CategoryFactory.create_batch(4)
@@ -554,6 +554,21 @@ def test_filter_by_multiple_conditions(self):
         assert project in retrieved_projects, retrieved_projects
 
 
+    def test_filter_by_limit_offset(self):
+        """Test that filter_by supports limit and offset options"""
+
+        AppFactoryMemory.create_batch(4)
+        all_projects = self.project_repo.filter_by()
+
+        first_two = self.project_repo.filter_by(limit=2)
+        last_two = self.project_repo.filter_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_projects[:2]
+        assert last_two == all_projects[2:]
+
+
     def test_save(self):
         """Test save persist the project"""
 
@@ -625,6 +640,28 @@ def test_delete(self):
         assert deleted is None, deleted
 
 
+    def test_delete_also_removes_dependant_resources(self):
+        """Test delete removes project tasks and taskruns too"""
+        from factories import (TaskFactoryMemory, TaskRunFactoryMemory,
+                               BlogpostFactoryMemory)
+        from helper.repositories import memo_task_repo, memo_blog_repo
+
+        project = AppFactoryMemory.create()
+        task = TaskFactoryMemory.create(app=project)
+        taskrun = TaskRunFactoryMemory.create(task=task)
+        blogpost = BlogpostFactoryMemory.create(app=project)
+
+        self.project_repo.delete(project, task_repo=memo_task_repo, blog_repo=memo_blog_repo)
+        deleted_task = memo_task_repo.get_task(task.id)
+        deleted_taskrun = memo_task_repo.get_task_run(taskrun.id)
+        deleted_blogpost = memo_blog_repo.get(blogpost.id)
+
+        assert deleted_task is None, deleted_task
+        assert deleted_taskrun is None, deleted_taskrun
+
+        memo_task_repo.clean()
+        memo_blog_repo.clean()
+
     def test_delete_only_deletes_projects(self):
         """Test delete raises a WrongObjectError if is requested to delete other
         than a project"""
@@ -721,6 +758,21 @@ def test_filter_categories_by_one_condition(self):
         assert should_be_missing not in retrieved_categories, retrieved_categories
 
 
+    def test_filter_category_by_limit_offset(self):
+        """Test that filter_categories_by supports limit and offset options"""
+
+        CategoryFactoryMemory.create_batch(4)
+        all_categories = self.project_repo.filter_categories_by()
+
+        first_two = self.project_repo.filter_categories_by(limit=2)
+        last_two = self.project_repo.filter_categories_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_categories[:2]
+        assert last_two == all_categories[2:]
+
+
     def test_save_category(self):
         """Test save_category persist the category"""
 

test/test_repository/test_task_repository.py

@@ -272,8 +272,8 @@ def test_filter_task_runs_support_yield_option(self):
             assert taskrun in task_runs
 
 
-    def test_filter_tasks_limit_offset(self):
-        """Test that filter_tasks_by supports limit and offset options"""
+    def test_filter_task_runs_limit_offset(self):
+        """Test that filter_task_runs_by supports limit and offset options"""
 
         TaskRunFactory.create_batch(4)
         all_task_runs = self.task_repo.filter_task_runs_by()
@@ -466,7 +466,7 @@ def test_delete_all_deletes_many_tasks(self):
             assert self.task_repo.get_task(task.id) is None, task
 
 
-    def test_delete_all_deletes_many_tasks(self):
+    def test_delete_all_deletes_dependant(self):
         """Test delete_all deletes dependant taskruns too"""
 
         task = TaskFactory.create()
@@ -651,6 +651,21 @@ def test_filter_tasks_support_yield_option(self):
             assert task in tasks
 
 
+    def test_filter_tasks_limit_offset(self):
+        """Test that filter_tasks_by supports limit and offset options"""
+
+        TaskFactoryMemory.create_batch(4)
+        all_tasks = self.task_repo.filter_tasks_by()
+
+        first_two = self.task_repo.filter_tasks_by(limit=2)
+        last_two = self.task_repo.filter_tasks_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_tasks[:2]
+        assert last_two == all_tasks[2:]
+
+
     def test_count_tasks_with_no_matches(self):
         """Test count_tasks_with returns 0 if no tasks match the query"""
 
@@ -786,6 +801,21 @@ def test_filter_task_runs_support_yield_option(self):
             assert taskrun in task_runs
 
 
+    def test_filter_task_runs_limit_offset(self):
+        """Test that filter_task_runs_by supports limit and offset options"""
+
+        TaskRunFactoryMemory.create_batch(4)
+        all_task_runs = self.task_repo.filter_task_runs_by()
+
+        first_two = self.task_repo.filter_task_runs_by(limit=2)
+        last_two = self.task_repo.filter_task_runs_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_task_runs[:2]
+        assert last_two == all_task_runs[2:]
+
+
     def test_count_task_runs_with_no_matches(self):
         """Test count_task_runs_with returns 0 if no taskruns match the query"""
 
@@ -923,6 +953,18 @@ def test_delete_task(self):
         assert deleted is None, deleted
 
 
+    def test_delete_task_deletes_dependant_taskruns(self):
+        """Test delete removes the dependant TaskRun instances"""
+
+        task = TaskFactoryMemory.create()
+        taskrun = TaskRunFactoryMemory.create(task=task)
+
+        self.task_repo.delete(task)
+        deleted = self.task_repo.get_task_run(taskrun.id)
+
+        assert deleted is None, deleted
+
+
     def test_delete_taskrun(self):
         """Test delete removes the TaskRun instance"""
 
@@ -954,6 +996,18 @@ def test_delete_all_deletes_many_tasks(self):
             assert self.task_repo.get_task(task.id) is None, task
 
 
+    def test_delete_all_deletes_dependant(self):
+        """Test delete_all deletes dependant taskruns too"""
+
+        task = TaskFactoryMemory.create()
+        taskrun = TaskRunFactoryMemory.create(task=task)
+
+        self.task_repo.delete_all([task])
+        deleted = self.task_repo.get_task_run(taskrun.id)
+
+        assert deleted is None, deleted
+
+
     def test_delete_all_deletes_many_taskruns(self):
         """Test delete_all deletes many taskruns at once"""
 

test/test_repository/test_user_repository.py

@@ -141,7 +141,7 @@ def test_filter_by_multiple_conditions(self):
         assert user in retrieved_users, retrieved_users
 
 
-    def test_filter_tasks_limit_offset(self):
+    def test_filter_by_limit_offset(self):
         """Test that filter_by supports limit and offset options"""
 
         UserFactory.create_batch(4)
@@ -403,6 +403,21 @@ def test_filter_by_multiple_conditions(self):
         assert user in retrieved_users, retrieved_users
 
 
+    def test_filter_by_limit_offset(self):
+        """Test that filter_by supports limit and offset options"""
+
+        UserFactoryMemory.create_batch(4)
+        all_users = self.user_repo.filter_by()
+
+        first_two = self.user_repo.filter_by(limit=2)
+        last_two = self.user_repo.filter_by(limit=2, offset=2)
+
+        assert len(first_two) == 2, first_two
+        assert len(last_two) == 2, last_two
+        assert first_two == all_users[:2]
+        assert last_two == all_users[2:]
+
+
     def test_search_by_name_returns_list(self):
         """Test search_by_name returns a list with search results"""