def test_all_users_not_in_project(self):
p = ProjectFactory()
u1 = UserProfileFactory(status='active')
u2 = UserProfileFactory(status='active')
p.add_manager(u1)
self.assertTrue(u2 in p.all_users_not_in_project())
self.assertFalse(u1 in p.all_users_not_in_project())
def setUp(self):
self.title = 'Test item title'
self.email = '*****@*****.**'
self.name = 'Item Submitter'
self.owner = UserProfileFactory()
self.assignee = UserProfileFactory()
self.project = ProjectFactory()
self.milestone = MilestoneFactory(project=self.project)
self.estimated_time = '1h'
self.target_date = '2015-01-01'
self.debug_info = 'debug info: zofjiojfojef'
self.post_data = {
'title': self.title,
'email': self.email,
'name': self.name,
'pid': smart_text(self.project.pk),
'mid': smart_text(self.milestone.pk),
'type': 'action item',
'owner': self.owner.username,
'assigned_to': self.assignee.username,
'estimated_time': self.estimated_time,
'target_date': self.target_date,
'debug_info': self.debug_info,
}
# Mock for passing the SafeOriginPermission
self.remote_host = 'http://example.columbia.edu'
def test_reassign(self):
i = ItemFactory()
u = UserProfileFactory()
assignee = UserProfileFactory()
i.reassign(u, assignee, '')
self.assertEqual(
Notify.objects.filter(item=i.iid, user=assignee.user).count(), 1)
def test_calc(self):
ProjectFactory()
UserProfileFactory()
UserProfileFactory()
UserProfileFactory()
calc = ProjectStatusCalculator()
calc.calc()
def test_personnel_present(self):
u1 = UserProfileFactory()
u2 = UserProfileFactory()
u3 = UserProfileFactory()
p = ProjectFactory()
p.add_personnel(u3)
f = ProjectPersonnelForm(pid=p.pid)
personnel_in_form = f.fields.get('personnel').queryset.all()
self.assertTrue(u1 in personnel_in_form)
self.assertTrue(u2 in personnel_in_form)
self.assertFalse(u3 in personnel_in_form)
def test_get_resolve_time_multiple_times(self):
i = ItemFactory()
u = UserProfileFactory()
td = Duration('1 hour').timedelta()
i.add_resolve_time(u, td)
u = UserProfileFactory()
td = Duration('1 hour').timedelta()
i.add_resolve_time(u, td)
resolve_time = i.get_resolve_time()
self.assertEqual(resolve_time, timedelta(0, 7200))
def test_add_item_valid_duration_and_timezone(self):
m = MilestoneFactory()
p = m.project
u = UserProfileFactory()
p.add_item(type='action item',
title="new item",
assigned_to=u,
owner=u,
milestone=m,
priority=1,
description="",
estimated_time="2 hours",
status='OPEN',
r_status='')
self.assertTrue(m.item_set.count() > 0)
i = m.item_set.first()
self.assertEqual(i.estimated_time.seconds, 7200)
# Assert that the last_mod time is within ten mins of what
# we expect.
now = timezone.now()
five_mins = timedelta(minutes=5)
self.assertTrue(i.last_mod < (now + five_mins))
self.assertTrue(i.last_mod > (now - five_mins))
self.assertEqual(Reminder.objects.count(), 0)
def test_get_resolve_zero(self):
i = ItemFactory()
u = UserProfileFactory()
td = Duration('0h').timedelta()
i.add_resolve_time(u, td)
resolve_time = i.get_resolve_time()
self.assertEqual(resolve_time, timedelta(0, 0))
def test_add_item_with_reminder(self):
m = MilestoneFactory()
p = m.project
u = UserProfileFactory()
p.add_item(
type='action item', title='new item',
assigned_to=u, owner=u, milestone=m,
priority=1, description='',
estimated_time='2 hours',
status='OPEN', r_status='',
reminder_duration='7d')
self.assertEqual(m.item_set.count(), 1)
self.assertEqual(
Reminder.objects.count(), 0,
'add_reminder requires a current_user')
# Same thing, with a current_user
i = p.add_item(
type='action item', title='new item',
assigned_to=u, owner=u, milestone=m,
priority=1, description='',
estimated_time='2 hours',
status='OPEN', r_status='',
current_user=u.user,
reminder_duration='7d')
self.assertEqual(m.item_set.count(), 2)
self.assertEqual(Reminder.objects.count(), 1)
r = Reminder.objects.first()
self.assertEqual(r.item, i)
self.assertEqual(r.reminder_time, timedelta(days=7))
def test_email_post(self):
p = ProjectFactory()
n = NodeFactory(subject="\r\n \r\n linebreaks", project=p)
u2 = UserProfileFactory(status='active')
p.add_manager(u2)
p.email_post(n, "a body", n.user.userprofile)
self.assertEqual(len(mail.outbox), 1)
def test_managers(self):
p = ProjectFactory()
u = UserProfileFactory()
p.add_manager(u)
self.assertEqual(set(p.managers()),
set([u, p.caretaker_user.userprofile,
p.project_manager_user.userprofile]))
def test_open_owned_items(self):
profile = UserProfileFactory()
# not the owner
ItemFactory(assigned_user=profile.user)
# owned but in the Someday/Maybe milestone
s = MilestoneFactory(name='Someday/Maybe')
ItemFactory(owner_user=profile.user, milestone=s)
# owned
i = ItemFactory(owner_user=profile.user)
qs = profile.open_owned_items()
self.assertEquals(qs.count(), 1)
self.assertEquals(qs.first(), i)
def test_add_resolve_time(self):
i = ItemFactory()
u = UserProfileFactory()
td = Duration('1 hour').timedelta()
i.add_resolve_time(u, td)
self.assertEqual(ActualTime.objects.count(), 1)
actualtime = ActualTime.objects.first()
self.assertEqual(actualtime.actual_time, timedelta(0, 3600))
def test_capacity_skip_weekend(self):
UserProfileFactory()
start = parse_datetime('2018-05-14 00:00:00-04:00')
end = parse_datetime('2018-05-25 23:59:59.999999-04:00')
calc = StaffCapacityCalculator(UserProfile.objects.all(), start, end)
self.assertEquals(calc.days(), 10)
self.assertEquals(calc.capacity_for_range(), 60)
def test_completed_time_for_interval(self):
u = UserProfileFactory()
p = ProjectFactory()
pu = ProjectUser(p, u)
start = datetime(year=2013, month=12, day=16).replace(tzinfo=utc)
end = datetime(year=2013, month=12, day=23).replace(tzinfo=utc)
r = pu.completed_time_for_interval(start, end)
self.assertEqual(r.total_seconds(), 0.0)
def test_personnel_in_project_sorts_groups_first(self):
p = ProjectFactory()
u = UserProfileFactory()
g = GroupFactory()
p.add_manager(u)
p.add_manager(g.grp)
r = p.personnel_in_project()
self.assertEqual(set(r), set([g.grp, u, p.caretaker_user.userprofile,
p.project_manager_user.userprofile]))
def test_user_accepts_user_or_userprofile(self):
u = UserFactory()
self.c.username = u.username
self.c.save()
self.assertEqual(self.c.user(), u.userprofile)
c = CommentFactory()
up = UserProfileFactory()
c.username = up.username
c.save()
self.assertEqual(c.user(), up)
def test_email_reply_with_bad_header(self):
n = NodeFactory()
p = ProjectFactory()
n.project = p
u = UserProfileFactory()
n.save()
class DummyReply(object):
subject = "a subject\r\nfoo"
n.email_reply("", u, DummyReply())
self.assertEqual(len(mail.outbox), 1)
def test_timeline_notempty(self):
m = MilestoneFactory()
p = m.project
u = UserProfileFactory()
p.add_item(type='action item', title="new item",
assigned_to=u, owner=u, milestone=m,
priority=1, description="",
estimated_time="2 hours",
status='OPEN', r_status='')
t = p.timeline()
self.assertEqual(len(t), 1)
def test_add_item_invalid_duration(self):
m = MilestoneFactory()
p = m.project
u = UserProfileFactory()
p.add_item(type='action item', title="new item",
assigned_to=u, owner=u, milestone=m,
priority=1, description="",
estimated_time="Invalid Estimated Time",
status='OPEN', r_status='')
self.assertTrue(m.item_set.count() > 0)
i = m.item_set.first()
self.assertEqual(i.estimated_time.seconds, 0)
self.assertEqual(Reminder.objects.count(), 0)
def test_resolve(self):
m = MilestoneFactory()
p = m.project
u = UserProfileFactory()
p.add_item(
type='action item', title='new item',
assigned_to=u, owner=u, milestone=m,
priority=1, description='',
estimated_time='1hr',
status='OPEN', r_status='')
i = m.item_set.first()
i.resolve(u, 'FIXED', 'test comment')
self.assertEqual(
Events.objects.filter(item=i, status='RESOLVED').count(), 1)
def test_remove_personnel(self):
p = ProjectFactory()
u = UserProfileFactory()
p.add_manager(u)
self.assertEqual(
set(p.managers()),
set([u, p.caretaker_user.userprofile,
p.project_manager_user.userprofile]))
p.remove_personnel(u)
self.assertEqual(
set(p.managers()),
set([p.caretaker_user.userprofile,
p.project_manager_user.userprofile]))
self.assertEqual(p.developers(), [])
self.assertEqual(p.guests(), [])
def test_add_item_created_by(self):
m = MilestoneFactory()
p = m.project
current_user = UserFactory()
u = UserProfileFactory()
p.add_item(
type='action item', title='new item',
assigned_to=u, owner=u, milestone=m,
current_user=current_user,
priority=1, description='',
estimated_time='2 hours',
status='OPEN', r_status='')
self.assertEqual(m.item_set.count(), 1)
item = m.item_set.first()
self.assertEqual(item.created_by, current_user)
def test_only_one_role_allowed(self):
p = ProjectFactory()
u = UserProfileFactory()
p.add_manager(u)
self.assertEqual(
set(p.managers()),
set([
u, p.caretaker_user.userprofile,
p.project_manager_user.userprofile
]))
self.assertEqual(p.developers(), [])
self.assertEqual(p.guests(), [])
p.add_developer(u)
self.assertEqual(p.managers(), [p.caretaker_user.userprofile])
self.assertEqual(p.developers(), [u])
self.assertEqual(p.guests(), [])
p.add_guest(u)
self.assertEqual(p.managers(), [p.caretaker_user.userprofile])
self.assertEqual(p.developers(), [])
self.assertEqual(p.guests(), [u])
p.add_manager(u)
self.assertEqual(
set(p.managers()),
set([
u, p.caretaker_user.userprofile,
p.project_manager_user.userprofile
]))
self.assertEqual(p.developers(), [])
self.assertEqual(p.guests(), [])
p.add_developer(u)
self.assertEqual(
p.managers(),
[p.caretaker_user.userprofile, p.project_manager_user.userprofile])
self.assertEqual(p.developers(), [u])
self.assertEqual(p.guests(), [])
p.add_guest(u)
self.assertEqual(
p.managers(),
[p.caretaker_user.userprofile, p.project_manager_user.userprofile])
self.assertEqual(p.developers(), [])
self.assertEqual(p.guests(), [u])
def test_calc(self):
start = parse_datetime('2017-05-15 00:00:00-04:00')
end = parse_datetime('2017-05-26 23:59:59.999999-04:00')
target = parse_datetime('2017-05-16 00:00:00-04:00')
profile = UserProfileFactory()
ItemFactory(assigned_user=profile.user,
estimated_time=timedelta(hours=5),
target_date=target)
ItemFactory(assigned_user=profile.user,
estimated_time=timedelta(hours=1))
calc = StaffCapacityCalculator(
UserProfile.objects.filter(user__id=profile.user.id), start, end)
self.assertEquals(calc.days(), 10)
self.assertEquals(calc.capacity_for_range(), 60)
data = calc.calc()
self.assertEquals(len(data), 1)
self.assertEquals(data[0]['user'], profile)
self.assertEquals(data[0]['booked'], 5)
self.assertEquals(data[0]['percent_booked'], '8.3')
self.assertEquals(data[0]['available'], 55)
self.assertEquals(data[0]['percent_available'], '91.7')
def test_developers(self):
p = ProjectFactory()
u = UserProfileFactory()
p.add_developer(u)
self.assertEqual(p.developers(), [u])
def test_add_subscriber_inactive_user(self):
i = ItemFactory()
u = UserProfileFactory(status='inactive')
i.add_subscriber(u)
with self.assertRaises(Notify.DoesNotExist):
Notify.objects.get(item=i.iid, user=u.user)
def test_calc(self):
UserProfileFactory()
UserProfileFactory()
UserProfileFactory()
calc = StaffReportCalculator(UserProfile.objects.all())
calc.calc(self.week_start, self.week_end)
def test_update_email(self):
i = ItemFactory(title="\r\n \r\n linebreaks")
u2 = UserProfileFactory(status='active')
NotifyFactory(item=i, user=u2.user)
i.update_email("a comment", i.owner_user.userprofile)
self.assertEqual(len(mail.outbox), 1)
def test_guests(self):
p = ProjectFactory()
u = UserProfileFactory()
p.add_guest(u)
self.assertEqual(p.guests(), [u])
