def setUp(self): # create librarian group and those members self.librarian_group = modelfactories.GroupFactory(name="Librarian") self.librarian1 = auth.UserF(is_active=True) self.librarian2 = auth.UserF(is_active=True) self.librarian1.groups.add(self.librarian_group) self.librarian1.save() self.librarian2.groups.add(self.librarian_group) self.librarian2.save() self.collection = modelfactories.CollectionFactory.create() self.editor = auth.UserF(is_active=True) self.journal = modelfactories.JournalFactory.create(editor=self.editor) self.issue = modelfactories.IssueFactory(journal=self.journal) self.board = editorial_modelfactories.EditorialBoardFactory.create(issue=self.issue) self.member = editorial_modelfactories.EditorialMemberFactory.create(board=self.board) # link journal to collection jmodels.Membership.objects.create(journal=self.journal, collection=self.collection, created_by=auth.UserF(is_active=True)) # link librarians and collection self.collection.add_user(self.librarian1) self.collection.add_user(self.librarian2) self.expected_recipients = [] self.expected_bcc_recipients = [self.librarian1.email, self.librarian2.email, ] self.expected_subject_sufix_by_action = { 'board_add_member': "Member of the journal board, was added", 'board_edit_member': "Member of the journal board, was edited", 'board_delete_member': "Member of the journal board, was deleted", }
def test_get_users_by_group_by_collections_only_one_user_match(self): # with: # create librarian group and those members group_name = "Librarian" librarian_group = modelfactories.GroupFactory(name=group_name) librarian1 = auth.UserF(is_active=True) librarian2 = auth.UserF(is_active=True) librarian1.groups.add(librarian_group) librarian1.save() librarian2.groups.add(librarian_group) librarian2.save() # create col1. user: librarian1 belongs to it col1 = modelfactories.CollectionFactory.create() col1.add_user(librarian1) # create col2. without users. col2 = modelfactories.CollectionFactory.create() # when: users = get_users_by_group_by_collections(group_name, [ col1, col2, ]) # then: self.assertEqual(1, len(users)) self.assertIn(librarian1, users) self.assertNotIn(librarian2, users)
def test_get_default_by_user_with_two_users(self): user1 = auth.UserF() user2 = auth.UserF() _makeUserProfile(user1) _makeUserProfile(user2) col1 = modelfactories.CollectionFactory.create() col1.make_default_to_user(user1) col2 = modelfactories.CollectionFactory.create() col2.add_user(user1) col2.make_default_to_user(user2) self.assertEqual(user1.get_profile().get_default_collection, col1) self.assertEqual(user2.get_profile().get_default_collection, col2)
def test_logged_user_access_user_configuration(self): user = auth.UserF(is_active=True) response = self.app.get(reverse('journalmanager.password_change'), user=user) self.assertTemplateUsed(response, 'accounts/password_change.html')
def test_get_default_by_user_with_two_users(self): user1 = auth.UserF() user2 = auth.UserF() col1 = CollectionFactory.create() col1.make_default_to_user(user1) col2 = CollectionFactory.create() col2.add_user(user1) col2.make_default_to_user(user2) from journalmanager import models self.assertEqual(models.Collection.objects.get_default_by_user(user1), col1) self.assertEqual(models.Collection.objects.get_default_by_user(user2), col2)
def test_logged_user_access_my_account(self): user = auth.UserF(is_active=True) response = self.app.get(reverse('journalmanager.my_account'), user=user) self.assertTemplateUsed(response, 'accounts/my_account.html')
def test_valid_is_editors(self): user = auth.UserF() journal = JournalFactory.create() journal.editors.add(user) self.assertTrue(journal.is_editor(user))
def setUp(self): self.user = auth.UserF(is_active=True) self.collection = modelfactories.CollectionFactory.create() self.collection.add_user(self.user, is_manager=False) self.journal = modelfactories.JournalFactory() self.journal.join(self.collection, self.user)
def test_is_accepted_method_with_accepted_checkin(self): import datetime user = auth.UserF(is_active=True) checkin = modelfactories.CheckinFactory( accepted_by=user, accepted_at=datetime.datetime.now()) self.assertTrue(checkin.is_accepted())
def test_accept_raises_ValueError_when_already_accepted(self): import datetime user = auth.UserF(is_active=True) checkin = modelfactories.CheckinFactory( accepted_by=user, accepted_at=datetime.datetime.now()) self.assertRaises(ValueError, lambda: checkin.accept(user))
def test_collection_as_default_to_user(self): collection = CollectionFactory.create() collection.make_default_to_user(auth.UserF()) from journalmanager import models collection_ = models.UserCollections.objects.get( is_default=True).collection self.assertEqual(collection_, collection)
def setUp(self): self.user = auth.UserF(username='******', password=HASH_FOR_123, email='*****@*****.**', is_active=True) self.profile = modelfactories.UserProfileFactory.build( user=self.user, email=self.user.email).save()
def test_add_user(self): user = auth.UserF() collection = CollectionFactory.create() collection.add_user(user) from journalmanager import models self.assertTrue( models.UserCollections.objects.get(user=user, collection=collection))
def test_logged_user_access_to_index(self): user = auth.UserF(is_active=True) collection = modelfactories.CollectionFactory.create() collection.add_user(user) response = self.app.get(reverse('index'), user=user) self.assertTemplateUsed(response, 'journalmanager/home_journal.html')
def setUp(self): self.editor = auth.UserF(is_active=True) self.journal = modelfactories.JournalFactory.create(editor=self.editor) self.issue = modelfactories.IssueFactory(journal=self.journal) self.expected_recipients = [self.editor.email, ] self.expected_subject_sufix_by_action = { 'issue_add_no_replicated_board': "Issue Board can't be replicated", 'issue_add_replicated_board': "Issue has a new replicated board", }
def test_user_can_NOT_receive_emails(self): # with user = auth.UserF(is_active=True) # when user_profile = user.get_profile() user_profile.email_notifications = False user_profile.save() # then self.assertFalse(user_profile.email_notifications)
def test_mailto_the_user_responsible_for_the_activity(self): user = auth.UserF(is_active=True) collection = modelfactories.CollectionFactory.create(name='Brasil') collection.add_user(user) journal = modelfactories.JournalFactory(creator=user) journal.join(collection, user) page = self.app.get(reverse('index'), user=user) page.mustcontain('href="mailto:%s"' % user.email)
def test_is_accepted_method_with_accepted_checkins(self): import datetime user = auth.UserF(is_active=True) article = modelfactories.ArticleFactory() modelfactories.CheckinFactory(accepted_by=user, accepted_at=datetime.datetime.now(), article=article) self.assertTrue(article.is_accepted())
def test_get_default_by_user_must_raise_doesnotexist_if_the_user_has_no_collections( self): user = auth.UserF() col1 = CollectionFactory.create() from journalmanager import models self.assertRaises( models.Collection.DoesNotExist, lambda: models.Collection.objects.get_default_by_user(user))
def test_accept(self): checkin = modelfactories.CheckinFactory() self.assertIsNone(checkin.accepted_by) self.assertIsNone(checkin.accepted_at) user = auth.UserF(is_active=True) checkin.accept(user) self.assertEqual(checkin.accepted_by, user) self.assertIsNotNone(checkin.accepted_at)
def test_remove_user_that_is_not_related_to_the_collection(self): user = auth.UserF() _makeUserProfile(user) self.collection.remove_user(user) self.assertRaises( models.UserCollections.DoesNotExist, lambda: models.UserCollections.objects.get(user=user, collection=self.collection) )
def test_get_first_alphabeticaly_when_default_is_not_set(self): user = auth.UserF() col1 = CollectionFactory.create() col1.add_user(user) col2 = CollectionFactory.create() col2.add_user(user) from journalmanager import models self.assertEqual(models.Collection.objects.get_default_by_user(user), col1)
def test_get_default_by_user_second_collection(self): user = auth.UserF() col1 = CollectionFactory.create() col1.make_default_to_user(user) col2 = CollectionFactory.create() col2.make_default_to_user(user) from journalmanager import models self.assertEqual(models.Collection.objects.get_default_by_user(user), col2)
def test_remove_user_that_is_not_related_to_the_collection(self): user = auth.UserF() collection = CollectionFactory.create() collection.remove_user(user) from journalmanager import models self.assertRaises( models.UserCollections.DoesNotExist, lambda: models.UserCollections.objects.get(user=user, collection=collection))
def test_redirect_to_restricted_page_after_successful_login(self): user = auth.UserF(is_active=True) perm = _makePermission(perm='list_journal', model='journal') user.user_permissions.add(perm) collection = modelfactories.CollectionFactory.create() collection.add_user(user) page = self.app.get(reverse('journal.index'), user=user) page.mustcontain('no items')
def test_active_collection_for_user_with_a_single_collection(self): user = auth.UserF(is_active=True) perm = _makePermission(perm='list_collection', model='collection') user.user_permissions.add(perm) _makeUserProfile(user) collection = modelfactories.CollectionFactory.create(name='Brasil') collection.add_user(user) page = self.app.get(reverse('index'), user=user) self.assertIn('data-active-collection="%s"' % collection.name, page)
def test_logged_user_access_users_not_being_manager_of_the_collection( self): user = auth.UserF(is_active=True) collection = modelfactories.CollectionFactory.create() collection.add_user(user) response = self.app.get(reverse('user.index'), user=user).follow() self.assertTemplateUsed(response, 'accounts/unauthorized.html') response.mustcontain('not authorized to access')
def test_auto_define_a_collection_as_default_when_it_is_the_unique(self): user = auth.UserF(is_active=True) perm = _makePermission(perm='list_collection', model='collection') user.user_permissions.add(perm) _makeUserProfile(user) collection = modelfactories.CollectionFactory.create() collection.add_user(user) page = self.app.get(reverse('index'), user=user) self.assertTrue(collection.name in page)
def test_wrong_username_and_right_password(self): user = auth.UserF(username='******', password=HASH_FOR_123, is_active=True) form = self.app.get(reverse('journalmanager.user_login')).forms[0] form['username'] = '******' form['password'] = '******' response = form.submit() self.assertTrue('not a valid username or password' in response.body) self.assertTemplateUsed(response, 'registration/login.html')
def test_get_users_by_group_by_collections_NO_collections(self): # with: # create librarian group and those members group_name = "Librarian" librarian_group = modelfactories.GroupFactory(name=group_name) librarian1 = auth.UserF(is_active=True) librarian2 = auth.UserF(is_active=True) librarian1.groups.add(librarian_group) librarian1.save() librarian2.groups.add(librarian_group) librarian2.save() # collection list is an empty list # when: users = get_users_by_group_by_collections(group_name, []) # then: self.assertEqual(0, len(users)) self.assertNotIn(librarian1, users) self.assertNotIn(librarian2, users)