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)
