def test_can_return_only_organisations_that_are_associated_with_a_valid_subscription(
self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
user = UserFactory.create()
org_1.members.add(user)
org_2.members.add(user)
org_3.members.add(user)
subscription_1 = JournalAccessSubscriptionFactory.create(
organisation=org_1)
subscription_2 = JournalAccessSubscriptionFactory.create(
organisation=org_2)
JournalAccessSubscriptionFactory.create(organisation=org_3)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt - dt.timedelta(days=8))
# Run & check
self.assertEqual(list(get_managed_organisations(user)), [
org_1,
])
def test_can_return_only_organisations_that_have_the_considered_users_in_their_members(
self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
user = UserFactory.create()
org_1.members.add(user)
subscription_1 = JournalAccessSubscriptionFactory.create(
organisation=org_1)
subscription_2 = JournalAccessSubscriptionFactory.create(
organisation=org_2)
subscription_3 = JournalAccessSubscriptionFactory.create(
organisation=org_3)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_3,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
# Run & check
self.assertEqual(list(get_managed_organisations(user)), [
org_1,
])
def test_can_return_only_organisations_that_have_the_considered_users_in_their_members(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
user = UserFactory.create()
org_1.members.add(user)
subscription_1 = JournalAccessSubscriptionFactory.create(organisation=org_1)
subscription_2 = JournalAccessSubscriptionFactory.create(organisation=org_2)
subscription_3 = JournalAccessSubscriptionFactory.create(organisation=org_3)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_3,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
# Run & check
self.assertEqual(list(get_managed_organisations(user)), [org_1, ])
def test_cannot_return_organisations_with_non_ongoing_subscriptions(self):
# Setup
now_dt = dt.datetime.now()
collection = CollectionFactory.create()
journal = JournalFactory(collection=collection)
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
OrganisationFactory.create()
subscription_1 = JournalAccessSubscriptionFactory.create(
organisation=org_1, journal=journal)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
subscription_2 = JournalAccessSubscriptionFactory.create(
organisation=org_2, collection=journal.collection)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt - dt.timedelta(days=5))
subscription_3 = JournalAccessSubscriptionFactory.create(organisation=org_3)
subscription_3.journals.add(journal)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_3,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
# Run & check
assert set(get_journal_organisation_subscribers(journal)) == set([org_1, org_3, ])
def test_cannot_return_organisations_with_non_ongoing_subscriptions(self):
# Setup
now_dt = dt.datetime.now()
collection = CollectionFactory.create()
journal = JournalFactory(collection=collection)
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
OrganisationFactory.create()
subscription_1 = JournalAccessSubscriptionFactory.create(
organisation=org_1, journal=journal)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
subscription_2 = JournalAccessSubscriptionFactory.create(
organisation=org_2, collection=journal.collection)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt - dt.timedelta(days=5))
subscription_3 = JournalAccessSubscriptionFactory.create(
organisation=org_3)
subscription_3.journals.add(journal)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_3,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
# Run & check
assert set(get_journal_organisation_subscribers(journal)) == set([
org_1,
org_3,
])
def test_return_all_organisations_for_superusers_and_staff_users(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
user_1 = UserFactory.create(is_superuser=True)
user_2 = UserFactory.create(is_staff=True)
# Run & check
self.assertEqual(list(get_managed_organisations(user_1)), [org_1, org_2, ])
self.assertEqual(list(get_managed_organisations(user_2)), [org_1, org_2, ])
def test_can_resolve_the_current_url_for_another_organisation(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
factory = RequestFactory()
base_url = reverse(
'userspace:library:home', kwargs={'organisation_pk': org_1.pk})
request = factory.get(base_url)
request.resolver_match = resolve(base_url)
# Run
url = library_url({'request': request}, org_2)
# Check
self.assertEqual(
url,
reverse('userspace:library:home', kwargs={'organisation_pk': org_2.pk}))
def test_return_all_organisations_for_superusers_and_staff_users(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
user_1 = UserFactory.create(is_superuser=True)
user_2 = UserFactory.create(is_staff=True)
# Run & check
self.assertEqual(list(get_managed_organisations(user_1)), [
org_1,
org_2,
])
self.assertEqual(list(get_managed_organisations(user_2)), [
org_1,
org_2,
])
def test_cannot_grant_access_to_an_article_if_it_is_associated_to_an_institutional_account_that_is_not_not_ongoing(
self
): # noqa
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(), localidentifier="test"
)
article = ArticleFactory.create(issue=issue)
organisation = OrganisationFactory.create()
subscription = JournalAccessSubscriptionFactory.create(journal=self.journal, organisation=organisation)
InstitutionIPAddressRangeFactory.create(subscription=subscription, ip_start="192.168.1.2", ip_end="192.168.1.4")
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = AnonymousUser()
# FIXME call middleware
request.subscription = None
parameters = request.META.copy()
parameters["HTTP_X_FORWARDED_FOR"] = "192.168.1.3"
request.META = parameters
view = MyView()
view.request = request
# Run # check
self.assertFalse(view.has_access())
def test_associates_the_subscription_type_to_the_request_in_case_of_institution(
self):
# Setup
now_dt = dt.datetime.now()
organisation = OrganisationFactory.create()
subscription = JournalAccessSubscriptionFactory(
organisation=organisation)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
InstitutionIPAddressRangeFactory.create(subscription=subscription,
ip_start='192.168.1.2',
ip_end='192.168.1.4')
request = self.factory.get('/')
request.user = AnonymousUser()
request.session = dict()
parameters = request.META.copy()
parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3'
request.META = parameters
middleware = SubscriptionMiddleware()
# Run
middleware.process_request(request)
# Check
self.assertEqual(request.subscription_type, 'institution')
self.assertEqual(request.subscription, subscription)
def test_associates_the_subscription_type_to_the_request_in_case_of_institution(self):
# Setup
now_dt = dt.datetime.now()
organisation = OrganisationFactory.create()
subscription = JournalAccessSubscriptionFactory(
organisation=organisation)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
InstitutionIPAddressRangeFactory.create(
subscription=subscription,
ip_start='192.168.1.2', ip_end='192.168.1.4')
request = self.factory.get('/')
parameters = request.META.copy()
parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3'
request.META = parameters
middleware = SubscriptionMiddleware()
# Run
middleware.process_request(request)
# Check
self.assertEqual(request.subscription_type, 'institution')
self.assertEqual(request.subscription, subscription)
def test_can_resolve_the_current_url_for_another_organisation(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
factory = RequestFactory()
base_url = reverse('userspace:library:home',
kwargs={'organisation_pk': org_1.pk})
request = factory.get(base_url)
request.resolver_match = resolve(base_url)
# Run
url = library_url({'request': request}, org_2)
# Check
self.assertEqual(
url,
reverse('userspace:library:home',
kwargs={'organisation_pk': org_2.pk}))
def setup(self):
self.organisation = OrganisationFactory.create()
# Set up some images used for doing image tests
images_dict = {}
# Fetch an image aimed to be resized
f = open(settings.MEDIA_ROOT + "/200x200.png", "rb")
images_dict['200x200'] = File(f)
self.images_dict = images_dict
yield
# teardown
# --
for img in self.images_dict.values():
img.close()
try:
self.organisation.badge.delete()
except:
pass
self.organisation.delete()
def setUp(self):
super(TestInstitutionIPAddressRangeCreateView, self).setUp()
self.organisation = OrganisationFactory.create()
self.organisation.members.add(self.user)
self.subscription = JournalAccessSubscriptionFactory.create(organisation=self.organisation)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=self.subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
def setUp(self):
super(TestOrganisationMemberCreateView, self).setUp()
self.organisation = OrganisationFactory.create()
self.organisation.members.add(self.user)
self.subscription = JournalAccessSubscriptionFactory.create(
organisation=self.organisation)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=self.subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
def setUp(self):
super(TestOrganisationScopeMixin, self).setUp()
self.factory = RequestFactory()
self.organisation = OrganisationFactory.create()
self.organisation.members.add(self.user)
self.subscription = JournalAccessSubscriptionFactory.create(organisation=self.organisation)
self.subscription = JournalAccessSubscriptionFactory.create(organisation=self.organisation)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=self.subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
def test_can_return_only_organisations_that_are_associated_with_a_valid_subscription(self):
# Setup
org_1 = OrganisationFactory.create()
org_2 = OrganisationFactory.create()
org_3 = OrganisationFactory.create()
user = UserFactory.create()
org_1.members.add(user)
org_2.members.add(user)
org_3.members.add(user)
subscription_1 = JournalAccessSubscriptionFactory.create(organisation=org_1)
subscription_2 = JournalAccessSubscriptionFactory.create(organisation=org_2)
JournalAccessSubscriptionFactory.create(organisation=org_3)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_1,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription_2,
start=now_dt - dt.timedelta(days=10),
end=now_dt - dt.timedelta(days=8))
# Run & check
self.assertEqual(list(get_managed_organisations(user)), [org_1, ])
def setUp(self):
super(TestInstitutionIPAddressRangeDeleteView, self).setUp()
self.organisation = OrganisationFactory.create()
self.organisation.members.add(self.user)
self.subscription = JournalAccessSubscriptionFactory.create(
organisation=self.organisation)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=self.subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
self.ip_range = InstitutionIPAddressRangeFactory.create(
subscription=self.subscription,
ip_start='10.0.0.0',
ip_end='11.0.0.0')
def test_can_grant_access_to_an_article_if_it_is_associated_to_an_institutional_account(self):
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(),
localidentifier='test')
article = ArticleFactory.create(issue=issue)
organisation = OrganisationFactory.create()
now_dt = dt.datetime.now()
subscription = JournalAccessSubscriptionFactory.create(
journal=self.journal, organisation=organisation)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
InstitutionIPAddressRangeFactory.create(
subscription=subscription,
ip_start='192.168.1.2', ip_end='192.168.1.4')
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get('/')
request.user = AnonymousUser()
request.session = dict()
parameters = request.META.copy()
parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3'
request.META = parameters
middleware.process_request(request)
view = MyView()
view.request = request
# Run # check
self.assertTrue(view.has_access())
def setup(self):
self.client = Client()
self.user = UserFactory.create(username='******')
self.user.set_password('notsecret')
self.user.save()
self.organisation = OrganisationFactory.create()
self.organisation.members.add(self.user)
self.subscription = JournalAccessSubscriptionFactory.create(organisation=self.organisation)
now_dt = dt.datetime.now()
JournalAccessSubscriptionPeriodFactory.create(
subscription=self.subscription,
start=now_dt - dt.timedelta(days=10),
end=now_dt + dt.timedelta(days=8))
# Set up some images used for doing image tests
images_dict = {}
# Fetch an image aimed to be resized
f = open(settings.MEDIA_ROOT + "/200x200.png", "rb")
images_dict['200x200'] = File(f)
self.images_dict = images_dict
yield
# teardown
# --
for img in self.images_dict.values():
img.close()
try:
self.organisation.badge.delete()
except:
pass
self.organisation.delete()
def test_cannot_grant_access_to_an_article_if_it_is_associated_to_an_institutional_account_that_is_not_not_ongoing(self): # noqa
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(),
localidentifier='test')
article = ArticleFactory.create(issue=issue)
organisation = OrganisationFactory.create()
subscription = JournalAccessSubscriptionFactory.create(
journal=self.journal, organisation=organisation)
InstitutionIPAddressRangeFactory.create(
subscription=subscription,
ip_start='192.168.1.2', ip_end='192.168.1.4')
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get('/')
request.user = AnonymousUser()
request.session = dict()
# FIXME call middleware
request.subscription = None
parameters = request.META.copy()
parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3'
request.META = parameters
view = MyView()
view.request = request
# Run # check
self.assertFalse(view.has_access())
def test_can_grant_access_to_an_article_if_it_is_associated_to_an_institutional_account(self):
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(), localidentifier="test"
)
article = ArticleFactory.create(issue=issue)
organisation = OrganisationFactory.create()
now_dt = dt.datetime.now()
subscription = JournalAccessSubscriptionFactory.create(journal=self.journal, organisation=organisation)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)
)
InstitutionIPAddressRangeFactory.create(subscription=subscription, ip_start="192.168.1.2", ip_end="192.168.1.4")
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = AnonymousUser()
parameters = request.META.copy()
parameters["HTTP_X_FORWARDED_FOR"] = "192.168.1.3"
request.META = parameters
middleware.process_request(request)
view = MyView()
view.request = request
# Run # check
self.assertTrue(view.has_access())
def test_cannot_return_managed_organisations_for_anonymous_users(self):
# Setup
OrganisationFactory.create()
user = AnonymousUser()
# Run & check
self.assertIsNone(get_managed_organisations(user))
def setup(self):
self.organisation = OrganisationFactory.create()
self.subscription = JournalAccessSubscriptionFactory(
organisation=self.organisation)
def setup(self):
self.organisation = OrganisationFactory.create()
self.subscription = JournalAccessSubscriptionFactory(organisation=self.organisation)
def setUp(self):
super(TestManageOrganisationSubscriptionIpsRule, self).setUp()
self.organisation = OrganisationFactory.create()
def setup(self):
self.organisation = OrganisationFactory.create()
def setup(self):
self.organisation = OrganisationFactory.create()
def test_cannot_return_managed_organisations_for_anonymous_users(self):
# Setup
OrganisationFactory.create()
user = AnonymousUser()
# Run & check
self.assertIsNone(get_managed_organisations(user))
def setUp(self):
super(TestManageOrganisationSubscriptionIpsRule, self).setUp()
self.organisation = OrganisationFactory.create()
def setUp(self):
super(TestOrganisationMembershipTokenCreateForm, self).setUp()
self.organisation = OrganisationFactory.create()
