udata 13.0.1.dev12__py3-none-any.whl → 14.4.1.dev7__py3-none-any.whl

udata/harvest/tests/test_api.py

@@ -5,12 +5,14 @@ import pytest
 from flask import url_for
 from pytest_mock import MockerFixture
 
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.dataset.factories import DatasetFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.user.factories import AdminFactory, UserFactory
+from udata.harvest.backends import get_enabled_backends
 from udata.models import Member, PeriodicTask
 from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import assert200, assert201, assert204, assert400, assert403, assert404
-from udata.tests.plugin import ApiClient
 from udata.utils import faker
 
 from .. import actions
@@ -18,20 +20,21 @@ from ..models import (
     VALIDATION_ACCEPTED,
     VALIDATION_PENDING,
     VALIDATION_REFUSED,
+    HarvestItem,
     HarvestSource,
     HarvestSourceValidation,
 )
-from .factories import HarvestSourceFactory, MockBackendsMixin
+from .factories import HarvestJobFactory, HarvestSourceFactory, MockBackendsMixin
 
 log = logging.getLogger(__name__)
 
 
 class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
-    def test_list_backends(self, api):
+    def test_list_backends(self):
         """It should fetch the harvest backends list from the API"""
-        response = api.get(url_for("api.harvest_backends"))
+        response = self.get(url_for("api.harvest_backends"))
         assert200(response)
-        assert len(response.json) == len(actions.list_backends())
+        assert len(response.json) == len(get_enabled_backends())
         for data in response.json:
             assert "id" in data
             assert "label" in data
@@ -39,87 +42,87 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             assert isinstance(data["filters"], (list, tuple))
             assert "extra_configs" in data
 
-    def test_list_sources(self, api):
+    def test_list_sources(self):
         sources = HarvestSourceFactory.create_batch(3)
 
-        response = api.get(url_for("api.harvest_sources"))
+        response = self.get(url_for("api.harvest_sources"))
         assert200(response)
         assert len(response.json["data"]) == len(sources)
 
-    def test_list_sources_exclude_deleted(self, api):
+    def test_list_sources_exclude_deleted(self):
         sources = HarvestSourceFactory.create_batch(3)
         HarvestSourceFactory.create_batch(2, deleted=datetime.utcnow())
 
-        response = api.get(url_for("api.harvest_sources"))
+        response = self.get(url_for("api.harvest_sources"))
         assert200(response)
         assert len(response.json["data"]) == len(sources)
 
-    def test_list_sources_include_deleted(self, api):
+    def test_list_sources_include_deleted(self):
         sources = HarvestSourceFactory.create_batch(3)
         sources.extend(HarvestSourceFactory.create_batch(2, deleted=datetime.utcnow()))
 
-        response = api.get(url_for("api.harvest_sources", deleted=True))
+        response = self.get(url_for("api.harvest_sources", deleted=True))
         assert200(response)
         assert len(response.json["data"]) == len(sources)
 
-    def test_list_sources_for_owner(self, api):
+    def test_list_sources_for_owner(self):
         owner = UserFactory()
         sources = HarvestSourceFactory.create_batch(3, owner=owner)
         HarvestSourceFactory()
 
         url = url_for("api.harvest_sources", owner=str(owner.id))
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
 
         assert len(response.json["data"]) == len(sources)
 
-    def test_list_sources_for_org(self, api):
+    def test_list_sources_for_org(self):
         org = OrganizationFactory()
         sources = HarvestSourceFactory.create_batch(3, organization=org)
         HarvestSourceFactory()
 
-        response = api.get(url_for("api.harvest_sources", owner=str(org.id)))
+        response = self.get(url_for("api.harvest_sources", owner=str(org.id)))
         assert200(response)
 
         assert len(response.json["data"]) == len(sources)
 
-    def test_list_sources_search(self, api):
+    def test_list_sources_search(self):
         HarvestSourceFactory.create_batch(3)
         source = HarvestSourceFactory(name="Moissonneur GeoNetwork de la ville de Rennes")
 
         url = url_for("api.harvest_sources", q="geonetwork rennes")
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
 
         assert len(response.json["data"]) == 1
         assert response.json["data"][0]["id"] == str(source.id)
 
-    def test_list_sources_paginate(self, api):
+    def test_list_sources_paginate(self):
         total = 25
         page_size = 20
         HarvestSourceFactory.create_batch(total)
 
         url = url_for("api.harvest_sources", page=1, page_size=page_size)
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
         assert len(response.json["data"]) == page_size
         assert response.json["total"] == total
 
         url = url_for("api.harvest_sources", page=2, page_size=page_size)
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
         assert len(response.json["data"]) == total - page_size
         assert response.json["total"] == total
 
         url = url_for("api.harvest_sources", page=3, page_size=page_size)
-        response = api.get(url)
+        response = self.get(url)
         assert404(response)
 
-    def test_create_source_with_owner(self, api):
+    def test_create_source_with_owner(self):
         """It should create and attach a new source to an owner"""
-        user = api.login()
+        user = self.login()
         data = {"name": faker.word(), "url": faker.url(), "backend": "factory"}
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert201(response)
 
@@ -128,9 +131,9 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         assert source["owner"]["id"] == str(user.id)
         assert source["organization"] is None
 
-    def test_create_source_with_org(self, api):
+    def test_create_source_with_org(self):
         """It should create and attach a new source to an organization"""
-        user = api.login()
+        user = self.login()
         member = Member(user=user, role="admin")
         org = OrganizationFactory(members=[member])
         data = {
@@ -139,7 +142,7 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             "backend": "factory",
             "organization": str(org.id),
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert201(response)
 
@@ -148,9 +151,9 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         assert source["owner"] is None
         assert source["organization"]["id"] == str(org.id)
 
-    def test_create_source_with_org_not_member(self, api):
+    def test_create_source_with_org_not_member(self):
         """It should create and attach a new source to an organization"""
-        user = api.login()
+        user = self.login()
         member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         data = {
@@ -159,13 +162,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             "backend": "factory",
             "organization": str(org.id),
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert403(response)
 
-    def test_create_source_with_config(self, api):
+    def test_create_source_with_config(self):
         """It should create a new source with configuration"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -186,7 +189,7 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ],
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert201(response)
 
@@ -207,9 +210,9 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             ],
         }
 
-    def test_create_source_with_unknown_filter(self, api):
+    def test_create_source_with_unknown_filter(self):
         """Can only use known filters in config"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -220,13 +223,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_bad_filter_type(self, api):
+    def test_create_source_with_bad_filter_type(self):
         """Can only use the xpected filter type"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -237,13 +240,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_bad_filter_format(self, api):
+    def test_create_source_with_bad_filter_format(self):
         """Filters should have the right format"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -254,13 +257,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_unknown_extra_config(self, api):
+    def test_create_source_with_unknown_extra_config(self):
         """Can only use known extra config in config"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -271,13 +274,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_bad_extra_config_type(self, api):
+    def test_create_source_with_bad_extra_config_type(self):
         """Can only use the expected extra config type"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -288,13 +291,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_bad_extra_config_format(self, api):
+    def test_create_source_with_bad_extra_config_format(self):
         """Extra config should have the right format"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -305,13 +308,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 ]
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_unknown_feature(self, api):
+    def test_create_source_with_unknown_feature(self):
         """Can only use known features in config"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -320,13 +323,13 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 "features": {"unknown": True},
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_false_feature(self, api):
+    def test_create_source_with_false_feature(self):
         """It should handled negative values"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -338,7 +341,7 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 }
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert201(response)
 
@@ -350,9 +353,9 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             }
         }
 
-    def test_create_source_with_not_boolean_feature(self, api):
+    def test_create_source_with_not_boolean_feature(self):
         """It should handled negative values"""
-        api.login()
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
@@ -363,28 +366,28 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
                 }
             },
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert400(response)
 
-    def test_create_source_with_config_with_custom_key(self, api):
-        api.login()
+    def test_create_source_with_config_with_custom_key(self):
+        self.login()
         data = {
             "name": faker.word(),
             "url": faker.url(),
             "backend": "factory",
             "config": {"custom": "value"},
         }
-        response = api.post(url_for("api.harvest_sources"), data)
+        response = self.post(url_for("api.harvest_sources"), data)
 
         assert201(response)
 
         source = response.json
         assert source["config"] == {"custom": "value"}
 
-    def test_update_source(self, api):
-        """It should update a source if owner or orga member"""
-        user = api.login()
+    def test_update_source(self):
+        """It should update a source if owner or orga admin"""
+        user = self.login()
         source = HarvestSourceFactory(owner=user)
         new_url = faker.url()
         data = {
@@ -394,20 +397,20 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             "backend": "factory",
         }
         api_url = url_for("api.harvest_source", source=source)
-        response = api.put(api_url, data)
+        response = self.put(api_url, data)
         assert200(response)
         assert response.json["url"] == new_url
 
-        # Source is now owned by orga, with user as member
-        source.organization = OrganizationFactory(members=[Member(user=user)])
+        # Source is now owned by orga, with user as admin
+        source.organization = OrganizationFactory(members=[Member(user=user, role="admin")])
         source.save()
         api_url = url_for("api.harvest_source", source=source)
-        response = api.put(api_url, data)
+        response = self.put(api_url, data)
         assert200(response)
 
-    def test_update_source_require_permission(self, api):
+    def test_update_source_require_permission(self):
         """It should not update a source if not the owner"""
-        api.login()
+        self.login()
         source = HarvestSourceFactory()
         new_url: str = faker.url()
         data = {
@@ -417,32 +420,32 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
             "backend": "factory",
         }
         api_url: str = url_for("api.harvest_source", source=source)
-        response = api.put(api_url, data)
+        response = self.put(api_url, data)
 
         assert403(response)
 
-    def test_validate_source(self, api):
+    def test_validate_source(self):
         """It should allow to validate a source if admin"""
-        user = api.login(AdminFactory())
+        user = self.login(AdminFactory())
         source = HarvestSourceFactory()
 
         data = {"state": VALIDATION_ACCEPTED}
         url = url_for("api.validate_harvest_source", source=source)
-        response = api.post(url, data)
+        response = self.post(url, data)
         assert200(response)
 
         source.reload()
         assert source.validation.state == VALIDATION_ACCEPTED
         assert source.validation.by == user
 
-    def test_reject_source(self, api):
+    def test_reject_source(self):
         """It should allow to reject a source if admin"""
-        user = api.login(AdminFactory())
+        user = self.login(AdminFactory())
         source = HarvestSourceFactory()
 
         data = {"state": VALIDATION_REFUSED, "comment": "Not valid"}
         url = url_for("api.validate_harvest_source", source=source)
-        response = api.post(url, data)
+        response = self.post(url, data)
         assert200(response)
 
         source.reload()
@@ -450,40 +453,40 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         assert source.validation.comment == "Not valid"
         assert source.validation.by == user
 
-    def test_validate_source_is_admin_only(self, api):
+    def test_validate_source_is_admin_only(self):
         """It should allow to validate a source if admin"""
-        api.login()
+        self.login()
         source = HarvestSourceFactory()
 
         data = {"validate": True}
         url = url_for("api.validate_harvest_source", source=source)
-        response = api.post(url, data)
+        response = self.post(url, data)
         assert403(response)
 
-    def test_get_source(self, api):
+    def test_get_source(self):
         source = HarvestSourceFactory()
 
         url = url_for("api.harvest_source", source=source)
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
 
-    def test_get_missing_source(self, api):
+    def test_get_missing_source(self):
         url = url_for("api.harvest_source", source="685bb38b9cb9284b93fd9e72")
-        response = api.get(url)
+        response = self.get(url)
         assert404(response)
 
-    def test_source_preview(self, api):
-        api.login()
-        source = HarvestSourceFactory(backend="factory")
+    def test_source_preview(self):
+        user = self.login()
+        source = HarvestSourceFactory(backend="factory", owner=user)
 
         url = url_for("api.preview_harvest_source", source=source)
-        response = api.get(url)
+        response = self.get(url)
         assert200(response)
 
     @pytest.mark.options(HARVEST_ENABLE_MANUAL_RUN=True)
-    def test_run_source(self, mocker: MockerFixture, api: ApiClient):
+    def test_run_source(self, mocker: MockerFixture):
         launch = mocker.patch.object(actions.harvest, "delay")
-        user = api.login()
+        user = self.login()
 
         source = HarvestSourceFactory(
             backend="factory",
@@ -492,15 +495,15 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         )
 
         url = url_for("api.run_harvest_source", source=source)
-        response = api.post(url)
+        response = self.post(url)
         assert200(response)
 
         launch.assert_called()
 
     @pytest.mark.options(HARVEST_ENABLE_MANUAL_RUN=False)
-    def test_cannot_run_source_if_disabled(self, mocker: MockerFixture, api: ApiClient):
+    def test_cannot_run_source_if_disabled(self, mocker: MockerFixture):
         launch = mocker.patch.object(actions.harvest, "delay")
-        user = api.login()
+        user = self.login()
 
         source = HarvestSourceFactory(
             backend="factory",
@@ -509,16 +512,16 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         )
 
         url = url_for("api.run_harvest_source", source=source)
-        response = api.post(url)
+        response = self.post(url)
         assert400(response)
 
         launch.assert_not_called()
 
     @pytest.mark.options(HARVEST_ENABLE_MANUAL_RUN=True)
-    def test_cannot_run_source_if_not_owned(self, mocker: MockerFixture, api: ApiClient):
+    def test_cannot_run_source_if_not_owned(self, mocker: MockerFixture):
         launch = mocker.patch.object(actions.harvest, "delay")
         other_user = UserFactory()
-        api.login()
+        self.login()
 
         source = HarvestSourceFactory(
             backend="factory",
@@ -527,15 +530,15 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         )
 
         url = url_for("api.run_harvest_source", source=source)
-        response = api.post(url)
+        response = self.post(url)
         assert403(response)
 
         launch.assert_not_called()
 
     @pytest.mark.options(HARVEST_ENABLE_MANUAL_RUN=True)
-    def test_cannot_run_source_if_not_validated(self, mocker: MockerFixture, api: ApiClient):
+    def test_cannot_run_source_if_not_validated(self, mocker: MockerFixture):
         launch = mocker.patch.object(actions.harvest, "delay")
-        user = api.login()
+        user = self.login()
 
         source = HarvestSourceFactory(
             backend="factory",
@@ -544,46 +547,46 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         )
 
         url = url_for("api.run_harvest_source", source=source)
-        response = api.post(url)
+        response = self.post(url)
         assert400(response)
 
         launch.assert_not_called()
 
-    def test_source_from_config(self, api):
-        api.login()
+    def test_source_from_config(self):
+        self.login()
         data = {"name": faker.word(), "url": faker.url(), "backend": "factory"}
-        response = api.post(url_for("api.preview_harvest_source_config"), data)
+        response = self.post(url_for("api.preview_harvest_source_config"), data)
         assert200(response)
 
-    def test_delete_source(self, api):
-        user = api.login()
+    def test_delete_source(self):
+        user = self.login()
         source = HarvestSourceFactory(owner=user)
 
         url = url_for("api.harvest_source", source=source)
-        response = api.delete(url)
+        response = self.delete(url)
         assert204(response)
 
         deleted_sources = HarvestSource.objects(deleted__exists=True)
         assert len(deleted_sources) == 1
 
-    def test_delete_source_require_permission(self, api):
+    def test_delete_source_require_permission(self):
         """It should not delete a source if not the owner"""
-        api.login()
+        self.login()
         source = HarvestSourceFactory()
 
         url = url_for("api.harvest_source", source=source)
-        response = api.delete(url)
+        response = self.delete(url)
 
         assert403(response)
 
-    def test_schedule_source(self, api):
+    def test_schedule_source(self):
         """It should allow to schedule a source if admin"""
-        api.login(AdminFactory())
+        self.login(AdminFactory())
         source = HarvestSourceFactory()
 
         data = "0 0 * * *"
         url = url_for("api.schedule_harvest_source", source=source)
-        response = api.post(url, data)
+        response = self.post(url, data)
         assert200(response)
 
         assert response.json["schedule"] == "0 0 * * *"
@@ -598,22 +601,22 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         assert periodic_task.crontab.month_of_year == "*"
         assert periodic_task.enabled
 
-    def test_schedule_source_is_admin_only(self, api):
+    def test_schedule_source_is_admin_only(self):
         """It should only allow admins to schedule a source"""
-        api.login()
+        self.login()
         source = HarvestSourceFactory()
 
         data = "0 0 * * *"
         url = url_for("api.schedule_harvest_source", source=source)
-        response = api.post(url, data)
+        response = self.post(url, data)
         assert403(response)
 
         source.reload()
         assert source.periodic_task is None
 
-    def test_unschedule_source(self, api):
+    def test_unschedule_source(self):
         """It should allow to unschedule a source if admin"""
-        api.login(AdminFactory())
+        self.login(AdminFactory())
         periodic_task = PeriodicTask.objects.create(
             task="harvest",
             name=faker.name(),
@@ -624,15 +627,15 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         source = HarvestSourceFactory(periodic_task=periodic_task)
 
         url = url_for("api.schedule_harvest_source", source=source)
-        response = api.delete(url)
+        response = self.delete(url)
         assert204(response)
 
         source.reload()
         assert source.periodic_task is None
 
-    def test_unschedule_source_is_admin_only(self, api):
+    def test_unschedule_source_is_admin_only(self):
         """It should only allow admins to unschedule a source"""
-        api.login()
+        self.login()
         periodic_task = PeriodicTask.objects.create(
             task="harvest",
             name=faker.name(),
@@ -643,8 +646,160 @@ class HarvestAPITest(MockBackendsMixin, PytestOnlyAPITestCase):
         source = HarvestSourceFactory(periodic_task=periodic_task)
 
         url = url_for("api.schedule_harvest_source", source=source)
-        response = api.delete(url)
+        response = self.delete(url)
         assert403(response)
 
         source.reload()
         assert source.periodic_task is not None
+
+    def test_list_items(self):
+        """It should fetch the harvest items list from the API for a specific job"""
+        job = HarvestJobFactory(
+            items=[
+                HarvestItem(dataset=DatasetFactory()),
+                HarvestItem(dataservice=DataserviceFactory()),
+                HarvestItem(dataset=DatasetFactory(), remote_url="https://my.remote.example.com"),
+            ],
+        )
+        response = self.get(url_for("api.harvest_job", ident=str(job.id)))
+        assert200(response)
+        assert len(response.json["items"]) == 3
+        assert set(response.json["items"][0].keys()) == set(
+            [
+                "created",
+                "started",
+                "ended",
+                "dataset",
+                "dataservice",
+                "remote_url",
+                "remote_id",
+                "args",
+                "errors",
+                "kwargs",
+                "logs",
+                "status",
+            ]
+        )
+        # Make sure appropriate dataset or dataservice is set
+        assert response.json["items"][0]["dataset"] is not None
+        assert response.json["items"][0]["dataservice"] is None
+        assert response.json["items"][1]["dataset"] is None
+        assert response.json["items"][1]["dataservice"] is not None
+        # Make sure remote_url is exposed if exists
+        assert response.json["items"][1]["remote_url"] is None
+        assert response.json["items"][2]["remote_url"] == "https://my.remote.example.com"
+
+    def test_get_source_permissions_as_anonymous(self):
+        """It should return all permissions as False for anonymous users"""
+        source = HarvestSourceFactory()
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        assert "permissions" in response.json
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is False
+        assert permissions["delete"] is False
+        assert permissions["run"] is False
+        assert permissions["preview"] is False
+        assert permissions["validate"] is False
+        assert permissions["schedule"] is False
+
+    def test_get_source_permissions_as_owner(self):
+        """It should return owner permissions as True for source owner"""
+        user = self.login()
+        source = HarvestSourceFactory(owner=user)
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is True
+        assert permissions["delete"] is True
+        assert permissions["run"] is True
+        assert permissions["preview"] is True
+        assert permissions["validate"] is False
+        assert permissions["schedule"] is False
+
+    def test_get_source_permissions_as_org_admin(self):
+        """It should return owner permissions as True for org admins"""
+        user = self.login()
+        member = Member(user=user, role="admin")
+        org = OrganizationFactory(members=[member])
+        source = HarvestSourceFactory(organization=org)
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is True
+        assert permissions["delete"] is True
+        assert permissions["run"] is True
+        assert permissions["preview"] is True
+        assert permissions["validate"] is False
+        assert permissions["schedule"] is False
+
+    def test_get_source_permissions_as_org_editor(self):
+        """It should return only preview permission as True for org editors"""
+        user = self.login()
+        member = Member(user=user, role="editor")
+        org = OrganizationFactory(members=[member])
+        source = HarvestSourceFactory(organization=org)
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is False
+        assert permissions["delete"] is False
+        assert permissions["run"] is False
+        assert permissions["preview"] is True
+        assert permissions["validate"] is False
+        assert permissions["schedule"] is False
+
+    def test_get_source_permissions_as_superadmin(self):
+        """It should return all permissions as True for admin users"""
+        self.login(AdminFactory())
+        source = HarvestSourceFactory()
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is True
+        assert permissions["delete"] is True
+        assert permissions["run"] is True
+        assert permissions["preview"] is True
+        assert permissions["validate"] is True
+        assert permissions["schedule"] is True
+
+    def test_get_source_permissions_as_other_user(self):
+        """It should return all permissions as False for non-owner users"""
+        self.login()
+        source = HarvestSourceFactory()  # owned by another user
+
+        url = url_for("api.harvest_source", source=source)
+        response = self.get(url)
+        assert200(response)
+
+        permissions = response.json["permissions"]
+        assert permissions["edit"] is False
+        assert permissions["delete"] is False
+        assert permissions["run"] is False
+        assert permissions["preview"] is False
+        assert permissions["validate"] is False
+        assert permissions["schedule"] is False
+
+    def test_preview_source_require_permission(self):
+        """It should not allow preview if not the owner"""
+        self.login()
+        source = HarvestSourceFactory()  # owned by another user
+
+        url = url_for("api.preview_harvest_source", source=source)
+        response = self.get(url)
+        assert403(response)