def test_can_grant_access_to_an_article_if_it_is_associated_to_an_individual_subscription(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) now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8) ) class MyView(ArticleAccessCheckMixin): def get_article(self): return article request = self.factory.get("/") request.user = self.user view = MyView() view.request = request middleware.process_request(request) # Run # check self.assertTrue(view.has_access())
def test_can_grant_access_to_an_article_if_it_is_associated_to_an_individual_subscription(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) now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) class MyView(ArticleAccessCheckMixin): def get_article(self): return article request = self.factory.get('/') request.user = self.user request.session = dict() view = MyView() view.request = request middleware.process_request(request) # Run # check self.assertTrue(view.has_access())
def test_cannot_handle_a_request_with_an_invalid_report_type(self): # Setup self.organisation.members.add(self.user) self.organisation.members.add(self.user) subscription = JournalAccessSubscriptionFactory.create(organisation=self.organisation) now_dt = dt.datetime.now() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8) ) data = self.get_report_request_body( start="2016-01-01", end="2016-02-01", requestor_id=self.organisation.id, customer_reference=self.organisation.id, report_type="bad", ) request = self.factory.post( "/", data=data, content_type="text/xml", **{"HTTP_SOAPACTION": "SushiService:GetReportIn"} ) # Run response = SushiWebServiceView.as_view()(request) # Check dom = et.fromstring(response.content) faultcode = dom.find(".//faultcode") assert faultcode.text == "SOAP-ENV:Server" faultstring = dom.find(".//faultstring") assert faultstring.text == "bad reports are not provided"
def test_cannot_handle_a_request_with_an_invalid_report_type(self): # Setup self.organisation.members.add(self.user) self.organisation.members.add(self.user) subscription = JournalAccessSubscriptionFactory.create( organisation=self.organisation) now_dt = dt.datetime.now() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) data = self.get_report_request_body( start='2016-01-01', end='2016-02-01', requestor_id=self.organisation.id, customer_reference=self.organisation.id, report_type='bad') request = self.factory.post( '/', data=data, content_type='text/xml', **{'HTTP_SOAPACTION': 'SushiService:GetReportIn'}) # Run response = SushiWebServiceView.as_view()(request) # Check dom = et.fromstring(response.content) faultcode = dom.find('.//faultcode') assert faultcode.text == 'SOAP-ENV:Server' faultstring = dom.find('.//faultstring') assert faultstring.text == 'bad reports are not provided'
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_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_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(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_cannot_clean_a_period_that_has_a_younger_concurrent_period(self): # Setup now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt + dt.timedelta(days=11), end=now_dt + dt.timedelta(days=15)) period = JournalAccessSubscriptionPeriodFactory.build( subscription=subscription, start=now_dt + dt.timedelta(days=10), end=now_dt + dt.timedelta(days=12)) # Run & check with pytest.raises(ValidationError): period.clean()
def test_can_return_only_the_valid_subscriptions(self): # Setup now_dt = dt.datetime.now() subscription_1 = JournalAccessSubscriptionFactory.create() subscription_2 = JournalAccessSubscriptionFactory.create() 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 assert list(JournalAccessSubscription.valid_objects.all()) == [subscription_1, ]
def test_cannot_clean_a_period_that_has_a_larger_concurrent_period(self): # Setup now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt + dt.timedelta(days=8), end=now_dt + dt.timedelta(days=14)) period = JournalAccessSubscriptionPeriodFactory.build( subscription=subscription, start=now_dt + dt.timedelta(days=10), end=now_dt + dt.timedelta(days=12)) # Run & check with pytest.raises(ValidationError): period.clean()
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_embeds_a_boolean_indicating_if_the_user_is_subscribed_to_the_current_journal(self): # Setup now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) self.client.login(username='******', password='******') url = reverse('public:journal:journal_detail', kwargs={'code': self.journal.code}) # Run response = self.client.get(url) # Check self.assertEqual(response.status_code, 200) self.assertTrue(response.context['user_has_access_to_journal'])
def test_knows_if_it_is_ongoing_or_not(self): # Setup now_dt = dt.datetime.now() subscription_1 = JournalAccessSubscriptionFactory.create() subscription_2 = JournalAccessSubscriptionFactory.create() 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 assert subscription_1.is_ongoing assert not subscription_2.is_ongoing
def test_embeds_a_boolean_indicating_if_the_user_is_subscribed_to_the_current_journal( self): # Setup now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create( user=self.user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) self.client.login(username='******', password='******') url = reverse('public:journal:journal_detail', kwargs={'code': self.journal.code}) # Run response = self.client.get(url) # Check self.assertEqual(response.status_code, 200) self.assertTrue(response.context['user_has_access_to_journal'])
def test_knows_if_a_simple_user_can_manage_organisation_subscription_ips(self): # Setup AuthorizationFactory.create( content_type=ContentType.objects.get_for_model(self.organisation), object_id=self.organisation.id, user=self.user, authorization_codename=AC.can_manage_organisation_subscription_ips.codename) self.organisation.members.add(self.user) subscription = JournalAccessSubscriptionFactory.create( journal=self.journal, organisation=self.organisation) now_dt = dt.datetime.now() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=8), end=now_dt + dt.timedelta(days=11)) # Run & check self.assertTrue( self.user.has_perm( 'subscription.manage_organisation_subscription_ips', self.organisation))
def test_associates_the_subscription_type_to_the_request_in_case_of_individual_access(self): # Setup now_dt = dt.datetime.now() user = UserFactory() subscription = JournalAccessSubscriptionFactory.create(user=user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) request = self.factory.get('/') request.user = user middleware = SubscriptionMiddleware() # Run middleware.process_request(request) # Check self.assertTrue(request.subscription_type == 'individual')
def test_cannot_clean_an_incoherent_period(self): # Setup now_dt = dt.datetime.now() subscription = JournalAccessSubscriptionFactory.create() period = JournalAccessSubscriptionPeriodFactory.build( subscription=subscription, start=now_dt + dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) # Run & check with pytest.raises(ValidationError): period.clean()
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 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_associates_the_subscription_type_to_the_request_in_case_of_individual_access( self): # Setup now_dt = dt.datetime.now() user = UserFactory() subscription = JournalAccessSubscriptionFactory.create( user=user, journal=self.journal) JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)) request = self.factory.get('/') request.user = user request.session = dict() middleware = SubscriptionMiddleware() # Run middleware.process_request(request) # Check self.assertTrue(request.subscription_type == 'individual')
def test_knows_if_a_simple_user_can_manage_organisation_subscription_ips( self): # Setup AuthorizationFactory.create( content_type=ContentType.objects.get_for_model(self.organisation), object_id=self.organisation.id, user=self.user, authorization_codename=AC.can_manage_organisation_subscription_ips. codename) self.organisation.members.add(self.user) subscription = JournalAccessSubscriptionFactory.create( journal=self.journal, organisation=self.organisation) now_dt = dt.datetime.now() JournalAccessSubscriptionPeriodFactory.create( subscription=subscription, start=now_dt - dt.timedelta(days=8), end=now_dt + dt.timedelta(days=11)) # Run & check self.assertTrue( self.user.has_perm( 'subscription.manage_organisation_subscription_ips', self.organisation))
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_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_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())