Add pool tests

9 files changed, 739 insertions, 0 deletions

diff --git a/server/szurubooru/tests/api/test_pool_category_creating.py b/server/szurubooru/tests/api/test_pool_category_creating.py
new file mode 100644
index 0000000..4accb92
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_category_creating.py
@@ -0,0 +1,58 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pool_categories, snapshots
+
+
+def _update_category_name(category, name):
+    category.name = name
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {'pool_categories:create': model.User.RANK_REGULAR},
+    })
+
+
+def test_creating_category(
+        pool_category_factory, user_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    category = pool_category_factory(name='meta')
+    db.session.add(category)
+
+    with patch('szurubooru.func.pool_categories.create_category'), \
+            patch('szurubooru.func.pool_categories.serialize_category'), \
+            patch('szurubooru.func.pool_categories.update_category_name'), \
+            patch('szurubooru.func.snapshots.create'):
+        pool_categories.create_category.return_value = category
+        pool_categories.update_category_name.side_effect = _update_category_name
+        pool_categories.serialize_category.return_value = 'serialized category'
+        result = api.pool_category_api.create_pool_category(
+            context_factory(
+                params={'name': 'meta', 'color': 'black'}, user=auth_user))
+        assert result == 'serialized category'
+        pool_categories.create_category.assert_called_once_with('meta', 'black')
+        snapshots.create.assert_called_once_with(category, auth_user)
+
+
+@pytest.mark.parametrize('field', ['name', 'color'])
+def test_trying_to_omit_mandatory_field(user_factory, context_factory, field):
+    params = {
+        'name': 'meta',
+        'color': 'black',
+    }
+    del params[field]
+    with pytest.raises(errors.ValidationError):
+        api.pool_category_api.create_pool_category(
+            context_factory(
+                params=params,
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+
+
+def test_trying_to_create_without_privileges(user_factory, context_factory):
+    with pytest.raises(errors.AuthError):
+        api.pool_category_api.create_pool_category(
+            context_factory(
+                params={'name': 'meta', 'color': 'black'},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)))
diff --git a/server/szurubooru/tests/api/test_pool_category_deleting.py b/server/szurubooru/tests/api/test_pool_category_deleting.py
new file mode 100644
index 0000000..72853ac
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_category_deleting.py
@@ -0,0 +1,76 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pool_categories, snapshots
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {'pool_categories:delete': model.User.RANK_REGULAR},
+    })
+
+
+def test_deleting(user_factory, pool_category_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    category = pool_category_factory(name='category')
+    db.session.add(pool_category_factory(name='root'))
+    db.session.add(category)
+    db.session.flush()
+    with patch('szurubooru.func.snapshots.delete'):
+        result = api.pool_category_api.delete_pool_category(
+            context_factory(params={'version': 1}, user=auth_user),
+            {'category_name': 'category'})
+        assert result == {}
+        assert db.session.query(model.PoolCategory).count() == 1
+        assert db.session.query(model.PoolCategory).one().name == 'root'
+        snapshots.delete.assert_called_once_with(category, auth_user)
+
+
+def test_trying_to_delete_used(
+        user_factory, pool_category_factory, pool_factory, context_factory):
+    category = pool_category_factory(name='category')
+    db.session.add(category)
+    db.session.flush()
+    pool = pool_factory(names=['pool'], category=category)
+    db.session.add(pool)
+    db.session.commit()
+    with pytest.raises(pool_categories.PoolCategoryIsInUseError):
+        api.pool_category_api.delete_pool_category(
+            context_factory(
+                params={'version': 1},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'category'})
+    assert db.session.query(model.PoolCategory).count() == 1
+
+
+def test_trying_to_delete_last(
+        user_factory, pool_category_factory, context_factory):
+    db.session.add(pool_category_factory(name='root'))
+    db.session.commit()
+    with pytest.raises(pool_categories.PoolCategoryIsInUseError):
+        api.pool_category_api.delete_pool_category(
+            context_factory(
+                params={'version': 1},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'root'})
+
+
+def test_trying_to_delete_non_existing(user_factory, context_factory):
+    with pytest.raises(pool_categories.PoolCategoryNotFoundError):
+        api.pool_category_api.delete_pool_category(
+            context_factory(user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'bad'})
+
+
+def test_trying_to_delete_without_privileges(
+        user_factory, pool_category_factory, context_factory):
+    db.session.add(pool_category_factory(name='category'))
+    db.session.commit()
+    with pytest.raises(errors.AuthError):
+        api.pool_category_api.delete_pool_category(
+            context_factory(
+                params={'version': 1},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'category_name': 'category'})
+    assert db.session.query(model.PoolCategory).count() == 1
diff --git a/server/szurubooru/tests/api/test_pool_category_retrieving.py b/server/szurubooru/tests/api/test_pool_category_retrieving.py
new file mode 100644
index 0000000..4a467c0
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_category_retrieving.py
@@ -0,0 +1,56 @@
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pool_categories
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {
+            'pool_categories:list': model.User.RANK_REGULAR,
+            'pool_categories:view': model.User.RANK_REGULAR,
+        },
+    })
+
+
+def test_retrieving_multiple(
+        user_factory, pool_category_factory, context_factory):
+    db.session.add_all([
+        pool_category_factory(name='c1'),
+        pool_category_factory(name='c2'),
+    ])
+    db.session.flush()
+    result = api.pool_category_api.get_pool_categories(
+        context_factory(user=user_factory(rank=model.User.RANK_REGULAR)))
+    assert [cat['name'] for cat in result['results']] == ['c1', 'c2']
+
+
+def test_retrieving_single(
+        user_factory, pool_category_factory, context_factory):
+    db.session.add(pool_category_factory(name='cat'))
+    db.session.flush()
+    result = api.pool_category_api.get_pool_category(
+        context_factory(user=user_factory(rank=model.User.RANK_REGULAR)),
+        {'category_name': 'cat'})
+    assert result == {
+        'name': 'cat',
+        'color': 'dummy',
+        'usages': 0,
+        'default': False,
+        'version': 1,
+    }
+
+
+def test_trying_to_retrieve_single_non_existing(user_factory, context_factory):
+    with pytest.raises(pool_categories.PoolCategoryNotFoundError):
+        api.pool_category_api.get_pool_category(
+            context_factory(user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': '-'})
+
+
+def test_trying_to_retrieve_single_without_privileges(
+        user_factory, context_factory):
+    with pytest.raises(errors.AuthError):
+        api.pool_category_api.get_pool_category(
+            context_factory(user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'category_name': '-'})
diff --git a/server/szurubooru/tests/api/test_pool_category_updating.py b/server/szurubooru/tests/api/test_pool_category_updating.py
new file mode 100644
index 0000000..9c9f743
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_category_updating.py
@@ -0,0 +1,108 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pool_categories, snapshots
+
+
+def _update_category_name(category, name):
+    category.name = name
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {
+            'pool_categories:edit:name': model.User.RANK_REGULAR,
+            'pool_categories:edit:color': model.User.RANK_REGULAR,
+            'pool_categories:set_default': model.User.RANK_REGULAR,
+        },
+    })
+
+
+def test_simple_updating(user_factory, pool_category_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    category = pool_category_factory(name='name', color='black')
+    db.session.add(category)
+    db.session.flush()
+    with patch('szurubooru.func.pool_categories.serialize_category'), \
+            patch('szurubooru.func.pool_categories.update_category_name'), \
+            patch('szurubooru.func.pool_categories.update_category_color'), \
+            patch('szurubooru.func.snapshots.modify'):
+        pool_categories.update_category_name.side_effect = _update_category_name
+        pool_categories.serialize_category.return_value = 'serialized category'
+        result = api.pool_category_api.update_pool_category(
+            context_factory(
+                params={'name': 'changed', 'color': 'white', 'version': 1},
+                user=auth_user),
+            {'category_name': 'name'})
+        assert result == 'serialized category'
+        pool_categories.update_category_name.assert_called_once_with(
+            category, 'changed')
+        pool_categories.update_category_color.assert_called_once_with(
+            category, 'white')
+        snapshots.modify.assert_called_once_with(category, auth_user)
+
+
+@pytest.mark.parametrize('field', ['name', 'color'])
+def test_omitting_optional_field(
+        user_factory, pool_category_factory, context_factory, field):
+    db.session.add(pool_category_factory(name='name', color='black'))
+    db.session.commit()
+    params = {
+        'name': 'changed',
+        'color': 'white',
+    }
+    del params[field]
+    with patch('szurubooru.func.pool_categories.serialize_category'), \
+            patch('szurubooru.func.pool_categories.update_category_name'):
+        api.pool_category_api.update_pool_category(
+            context_factory(
+                params={**params, **{'version': 1}},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'name'})
+
+
+def test_trying_to_update_non_existing(user_factory, context_factory):
+    with pytest.raises(pool_categories.PoolCategoryNotFoundError):
+        api.pool_category_api.update_pool_category(
+            context_factory(
+                params={'name': ['dummy']},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'bad'})
+
+
+@pytest.mark.parametrize('params', [
+    {'name': 'whatever'},
+    {'color': 'whatever'},
+])
+def test_trying_to_update_without_privileges(
+        user_factory, pool_category_factory, context_factory, params):
+    db.session.add(pool_category_factory(name='dummy'))
+    db.session.commit()
+    with pytest.raises(errors.AuthError):
+        api.pool_category_api.update_pool_category(
+            context_factory(
+                params={**params, **{'version': 1}},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'category_name': 'dummy'})
+
+
+def test_set_as_default(user_factory, pool_category_factory, context_factory):
+    category = pool_category_factory(name='name', color='black')
+    db.session.add(category)
+    db.session.commit()
+    with patch('szurubooru.func.pool_categories.serialize_category'), \
+            patch('szurubooru.func.pool_categories.set_default_category'):
+        pool_categories.update_category_name.side_effect = _update_category_name
+        pool_categories.serialize_category.return_value = 'serialized category'
+        result = api.pool_category_api.set_pool_category_as_default(
+            context_factory(
+                params={
+                    'name': 'changed',
+                    'color': 'white',
+                    'version': 1,
+                },
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'category_name': 'name'})
+        assert result == 'serialized category'
+        pool_categories.set_default_category.assert_called_once_with(category)
diff --git a/server/szurubooru/tests/api/test_pool_creating.py b/server/szurubooru/tests/api/test_pool_creating.py
new file mode 100644
index 0000000..5eeb2e2
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_creating.py
@@ -0,0 +1,82 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, model, errors
+from szurubooru.func import pools, posts, snapshots
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({'privileges': {'pools:create': model.User.RANK_REGULAR}})
+
+
+def test_creating_simple_pools(pool_factory, user_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    pool = pool_factory()
+    with patch('szurubooru.func.pools.create_pool'), \
+            patch('szurubooru.func.pools.get_or_create_pools_by_names'), \
+            patch('szurubooru.func.pools.serialize_pool'), \
+            patch('szurubooru.func.snapshots.create'):
+        posts.get_posts_by_ids.return_value = ([], [])
+        pools.create_pool.return_value = pool
+        pools.serialize_pool.return_value = 'serialized pool'
+        result = api.pool_api.create_pool(
+            context_factory(
+                params={
+                    'names': ['pool1', 'pool2'],
+                    'category': 'default',
+                    'description': 'desc',
+                    'posts': [1, 2],
+                },
+                user=auth_user))
+        assert result == 'serialized pool'
+        pools.create_pool.assert_called_once_with(
+            ['pool1', 'pool2'], 'default', [1, 2])
+        snapshots.create.assert_called_once_with(pool, auth_user)
+
+
+@pytest.mark.parametrize('field', ['names', 'category'])
+def test_trying_to_omit_mandatory_field(user_factory, context_factory, field):
+    params = {
+        'names': ['pool1', 'pool2'],
+        'category': 'default',
+        'description': 'desc',
+        'posts': [],
+    }
+    del params[field]
+    with pytest.raises(errors.ValidationError):
+        api.pool_api.create_pool(
+            context_factory(
+                params=params,
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+
+
+@pytest.mark.parametrize('field', ['description', 'posts'])
+def test_omitting_optional_field(
+        pool_factory, user_factory, context_factory, field):
+    params = {
+        'names': ['pool1', 'pool2'],
+        'category': 'default',
+        'description': 'desc',
+        'posts': [],
+    }
+    del params[field]
+    with patch('szurubooru.func.pools.create_pool'), \
+            patch('szurubooru.func.pools.serialize_pool'):
+        pools.create_pool.return_value = pool_factory()
+        api.pool_api.create_pool(
+            context_factory(
+                params=params,
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+
+
+def test_trying_to_create_pool_without_privileges(
+        user_factory, context_factory):
+    with pytest.raises(errors.AuthError):
+        api.pool_api.create_pool(
+            context_factory(
+                params={
+                    'names': ['pool'],
+                    'category': 'default',
+                    'posts': [],
+                },
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)))
diff --git a/server/szurubooru/tests/api/test_pool_deleting.py b/server/szurubooru/tests/api/test_pool_deleting.py
new file mode 100644
index 0000000..e29656d
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_deleting.py
@@ -0,0 +1,61 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pools, snapshots
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({'privileges': {'pools:delete': model.User.RANK_REGULAR}})
+
+
+def test_deleting(user_factory, pool_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    pool = pool_factory(id=1)
+    db.session.add(pool)
+    db.session.commit()
+    with patch('szurubooru.func.snapshots.delete'):
+        result = api.pool_api.delete_pool(
+            context_factory(params={'version': 1}, user=auth_user),
+            {'pool_id': 1})
+        assert result == {}
+        assert db.session.query(model.Pool).count() == 0
+        snapshots.delete.assert_called_once_with(pool, auth_user)
+
+
+def test_deleting_used(
+        user_factory, pool_factory, context_factory, post_factory):
+    pool = pool_factory(id=1)
+    post = post_factory(id=1)
+    pool.posts.append(post)
+    db.session.add_all([pool, post])
+    db.session.commit()
+    api.pool_api.delete_pool(
+        context_factory(
+            params={'version': 1},
+            user=user_factory(rank=model.User.RANK_REGULAR)),
+        {'pool_id': 1})
+    db.session.refresh(post)
+    assert db.session.query(model.Pool).count() == 0
+    assert db.session.query(model.PoolPost).count() == 0
+    assert post.pools == []
+
+
+def test_trying_to_delete_non_existing(user_factory, context_factory):
+    with pytest.raises(pools.PoolNotFoundError):
+        api.pool_api.delete_pool(
+            context_factory(user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'pool_id': 9999})
+
+
+def test_trying_to_delete_without_privileges(
+        user_factory, pool_factory, context_factory):
+    db.session.add(pool_factory(id=1))
+    db.session.commit()
+    with pytest.raises(errors.AuthError):
+        api.pool_api.delete_pool(
+            context_factory(
+                params={'version': 1},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'pool_id': 1})
+    assert db.session.query(model.Pool).count() == 1
diff --git a/server/szurubooru/tests/api/test_pool_merging.py b/server/szurubooru/tests/api/test_pool_merging.py
new file mode 100644
index 0000000..dc462d2
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_merging.py
@@ -0,0 +1,98 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pools, snapshots
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({'privileges': {'pools:merge': model.User.RANK_REGULAR}})
+
+
+def test_merging(user_factory, pool_factory, context_factory, post_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    source_pool = pool_factory(id=1)
+    target_pool = pool_factory(id=2)
+    db.session.add_all([source_pool, target_pool])
+    db.session.flush()
+    assert source_pool.post_count == 0
+    assert target_pool.post_count == 0
+    post = post_factory(id=1)
+    source_pool.posts = [post]
+    db.session.add(post)
+    db.session.commit()
+    assert source_pool.post_count == 1
+    assert target_pool.post_count == 0
+    with patch('szurubooru.func.pools.serialize_pool'), \
+            patch('szurubooru.func.pools.merge_pools'), \
+            patch('szurubooru.func.snapshots.merge'):
+        api.pool_api.merge_pools(
+            context_factory(
+                params={
+                    'removeVersion': 1,
+                    'mergeToVersion': 1,
+                    'remove': 1,
+                    'mergeTo': 2,
+                },
+                user=auth_user))
+        pools.merge_pools.called_once_with(source_pool, target_pool)
+        snapshots.merge.assert_called_once_with(
+            source_pool, target_pool, auth_user)
+
+
+@pytest.mark.parametrize(
+    'field', ['remove', 'mergeTo', 'removeVersion', 'mergeToVersion'])
+def test_trying_to_omit_mandatory_field(
+        user_factory, pool_factory, context_factory, field):
+    db.session.add_all([
+        pool_factory(id=1),
+        pool_factory(id=2),
+    ])
+    db.session.commit()
+    params = {
+        'removeVersion': 1,
+        'mergeToVersion': 1,
+        'remove': 1,
+        'mergeTo': 2,
+    }
+    del params[field]
+    with pytest.raises(errors.ValidationError):
+        api.pool_api.merge_pools(
+            context_factory(
+                params=params,
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+
+
+def test_trying_to_merge_non_existing(
+        user_factory, pool_factory, context_factory):
+    db.session.add(pool_factory(id=1))
+    db.session.commit()
+    with pytest.raises(pools.PoolNotFoundError):
+        api.pool_api.merge_pools(
+            context_factory(
+                params={'remove': 1, 'mergeTo': 9999},
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+    with pytest.raises(pools.PoolNotFoundError):
+        api.pool_api.merge_pools(
+            context_factory(
+                params={'remove': 9999, 'mergeTo': 1},
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+
+
+def test_trying_to_merge_without_privileges(
+        user_factory, pool_factory, context_factory):
+    db.session.add_all([
+        pool_factory(id=1),
+        pool_factory(id=2),
+    ])
+    db.session.commit()
+    with pytest.raises(errors.AuthError):
+        api.pool_api.merge_pools(
+            context_factory(
+                params={
+                    'removeVersion': 1,
+                    'mergeToVersion': 1,
+                    'remove': 1,
+                    'mergeTo': 2,
+                },
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)))
diff --git a/server/szurubooru/tests/api/test_pool_retrieving.py b/server/szurubooru/tests/api/test_pool_retrieving.py
new file mode 100644
index 0000000..e48565a
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_retrieving.py
@@ -0,0 +1,72 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pools
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {
+            'pools:list': model.User.RANK_REGULAR,
+            'pools:view': model.User.RANK_REGULAR,
+        },
+    })
+
+
+def test_retrieving_multiple(user_factory, pool_factory, context_factory):
+    pool1 = pool_factory(id=1)
+    pool2 = pool_factory(id=2)
+    db.session.add_all([pool2, pool1])
+    db.session.flush()
+    with patch('szurubooru.func.pools.serialize_pool'):
+        pools.serialize_pool.return_value = 'serialized pool'
+        result = api.pool_api.get_pools(
+            context_factory(
+                params={'query': '', 'offset': 0},
+                user=user_factory(rank=model.User.RANK_REGULAR)))
+        assert result == {
+            'query': '',
+            'offset': 0,
+            'limit': 100,
+            'total': 2,
+            'results': ['serialized pool', 'serialized pool'],
+        }
+
+
+def test_trying_to_retrieve_multiple_without_privileges(
+        user_factory, context_factory):
+    with pytest.raises(errors.AuthError):
+        api.pool_api.get_pools(
+            context_factory(
+                params={'query': '', 'offset': 0},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)))
+
+
+def test_retrieving_single(user_factory, pool_factory, context_factory):
+    db.session.add(pool_factory(id=1))
+    db.session.flush()
+    with patch('szurubooru.func.pools.serialize_pool'):
+        pools.serialize_pool.return_value = 'serialized pool'
+        result = api.pool_api.get_pool(
+            context_factory(
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'pool_id': 1})
+        assert result == 'serialized pool'
+
+
+def test_trying_to_retrieve_single_non_existing(user_factory, context_factory):
+    with pytest.raises(pools.PoolNotFoundError):
+        api.pool_api.get_pool(
+            context_factory(
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'pool_id': 1})
+
+
+def test_trying_to_retrieve_single_without_privileges(
+        user_factory, context_factory):
+    with pytest.raises(errors.AuthError):
+        api.pool_api.get_pool(
+            context_factory(
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'pool_id': 1})
diff --git a/server/szurubooru/tests/api/test_pool_updating.py b/server/szurubooru/tests/api/test_pool_updating.py
new file mode 100644
index 0000000..52eddc9
--- /dev/null
+++ b/server/szurubooru/tests/api/test_pool_updating.py
@@ -0,0 +1,128 @@
+from unittest.mock import patch
+import pytest
+from szurubooru import api, db, model, errors
+from szurubooru.func import pools, posts, snapshots
+
+
+@pytest.fixture(autouse=True)
+def inject_config(config_injector):
+    config_injector({
+        'privileges': {
+            'pools:create': model.User.RANK_REGULAR,
+            'pools:edit:names': model.User.RANK_REGULAR,
+            'pools:edit:category': model.User.RANK_REGULAR,
+            'pools:edit:description': model.User.RANK_REGULAR,
+            'pools:edit:posts': model.User.RANK_REGULAR,
+        },
+    })
+
+
+def test_simple_updating(user_factory, pool_factory, context_factory):
+    auth_user = user_factory(rank=model.User.RANK_REGULAR)
+    pool = pool_factory(id=1, names=['pool1', 'pool2'])
+    db.session.add(pool)
+    db.session.commit()
+    with patch('szurubooru.func.pools.create_pool'), \
+         patch('szurubooru.func.posts.get_posts_by_ids'), \
+         patch('szurubooru.func.pools.update_pool_names'), \
+         patch('szurubooru.func.pools.update_pool_category_name'), \
+         patch('szurubooru.func.pools.update_pool_description'), \
+         patch('szurubooru.func.pools.update_pool_posts'), \
+         patch('szurubooru.func.pools.serialize_pool'), \
+         patch('szurubooru.func.snapshots.modify'):
+        posts.get_posts_by_ids.return_value = ([], [])
+        pools.serialize_pool.return_value = 'serialized pool'
+        result = api.pool_api.update_pool(
+            context_factory(
+                params={
+                    'version': 1,
+                    'names': ['pool3'],
+                    'category': 'series',
+                    'description': 'desc',
+                    'posts': [1, 2]
+                },
+                user=auth_user),
+            {'pool_id': 1})
+        assert result == 'serialized pool'
+        pools.create_pool.assert_not_called()
+        pools.update_pool_names.assert_called_once_with(pool, ['pool3'])
+        pools.update_pool_category_name.assert_called_once_with(pool, 'series')
+        pools.update_pool_description.assert_called_once_with(pool, 'desc')
+        pools.update_pool_posts.assert_called_once_with(pool, [1, 2])
+        pools.serialize_pool.assert_called_once_with(pool, options=[])
+        snapshots.modify.assert_called_once_with(pool, auth_user)
+
+
+@pytest.mark.parametrize(
+    'field', [
+        'names',
+        'category',
+        'description',
+        'posts',
+    ])
+def test_omitting_optional_field(
+        user_factory, pool_factory, context_factory, field):
+    db.session.add(pool_factory(id=1))
+    db.session.commit()
+    params = {
+        'names': ['pool1', 'pool2'],
+        'category': 'default',
+        'description': 'desc',
+        'posts': [],
+    }
+    del params[field]
+    with patch('szurubooru.func.pools.create_pool'), \
+         patch('szurubooru.func.pools.update_pool_names'), \
+         patch('szurubooru.func.pools.update_pool_category_name'), \
+         patch('szurubooru.func.pools.serialize_pool'):
+        api.pool_api.update_pool(
+            context_factory(
+                params={**params, **{'version': 1}},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'pool_id': 1})
+
+
+def test_trying_to_update_non_existing(user_factory, context_factory):
+    with pytest.raises(pools.PoolNotFoundError):
+        api.pool_api.update_pool(
+            context_factory(
+                params={'names': ['dummy']},
+                user=user_factory(rank=model.User.RANK_REGULAR)),
+            {'pool_id': 9999})
+
+
+@pytest.mark.parametrize('params', [
+    {'names': ['whatever']},
+    {'category': 'whatever'},
+    {'posts': [1]},
+])
+def test_trying_to_update_without_privileges(
+        user_factory, pool_factory, context_factory, params):
+    db.session.add(pool_factory(id=1))
+    db.session.commit()
+    with pytest.raises(errors.AuthError):
+        api.pool_api.update_pool(
+            context_factory(
+                params={**params, **{'version': 1}},
+                user=user_factory(rank=model.User.RANK_ANONYMOUS)),
+            {'pool_id': 1})
+
+
+def test_trying_to_create_pools_without_privileges(
+        config_injector, context_factory, pool_factory, user_factory):
+    pool = pool_factory(id=1)
+    db.session.add(pool)
+    db.session.commit()
+    config_injector({'privileges': {
+        'pools:create': model.User.RANK_ADMINISTRATOR,
+        'pools:edit:posts': model.User.RANK_REGULAR,
+    },
+                     'delete_source_files': False})
+    with patch('szurubooru.func.posts.get_posts_by_ids'):
+        posts.get_posts_by_ids.return_value = ([], ['new-post'])
+        with pytest.raises(errors.AuthError):
+            api.pool_api.create_pool(
+                context_factory(
+                    params={'posts': [1, 2], 'version': 1},
+                    user=user_factory(rank=model.User.RANK_REGULAR)),
+                {'pool_id': 1})