def test_add_reminder(self):
i = ItemFactory(title='\r\n \r\n linebreaks')
u = UserFactory()
r = i.add_reminder('5d', u)
self.assertEqual(r.item, i)
self.assertEqual(r.user, u)
self.assertEqual(r.reminder_time, timedelta(days=5))
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_get_resolve_time_1h(self):
i = ItemFactory()
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, 3600))
def test_post_comment(self):
i = ItemFactory()
i.save()
r = self.c.post(
"/api/1.0/git/",
dict(iid=i.iid, email=i.assigned_to.email, comment="a comment"))
self.assertEqual(r.status_code, 200)
self.assertEqual(r.content, "ok")
def test_add_project_notification(self):
self.assertEqual(Notify.objects.count(), 0)
i = ItemFactory()
i.add_project_notification()
self.assertEqual(Notify.objects.count(), 2)
n = Notify.objects.first()
self.assertEqual(n.item, i)
self.assertEqual(n.user, i.milestone.project.caretaker_user)
def test_post_fixed(self):
i = ItemFactory()
i.save()
r = self.c.post(
"/api/1.0/git/", dict(status="FIXED", iid=i.iid, email=i.assigned_to.email, comment="a comment")
)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.content, "ok")
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_verified_items(self):
i = ItemFactory(status='OPEN')
i2 = ItemFactory(status='INPROGRESS', milestone=i.milestone)
i3 = ItemFactory(status='RESOLVED', milestone=i.milestone)
i4 = ItemFactory(status='VERIFIED', milestone=i.milestone)
r = i.milestone.verified_items()
self.assertNotIn(i, r)
self.assertNotIn(i2, r)
self.assertNotIn(i3, r)
self.assertIn(i4, r)
def test_post_fixed_with_resolve_time(self):
i = ItemFactory()
i.save()
r = self.c.post(
"/api/1.0/git/",
dict(status='FIXED',
iid=i.iid,
email=i.assigned_to.email,
resolve_time='1 hour',
comment="a comment"))
self.assertEqual(r.status_code, 200)
self.assertEqual(r.content, "ok")
def test_post_fixed_with_resolve_time(self):
i = ItemFactory()
i.save()
r = self.c.post(
"/api/1.0/git/",
dict(status='FIXED',
iid=i.iid,
email=i.assigned_to.email,
resolve_time='1 hour',
comment="a comment")
)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.content, "ok")
def test_post_comment(self):
i = ItemFactory()
i.save()
r = self.c.post(
self.url,
dict(iid=i.iid,
email=i.assigned_user.userprofile.email,
comment="a comment"))
self.assertEqual(r.status_code, 200)
content = json.loads(r.content)
self.assertEqual(content['iid'], i.iid)
self.assertEqual(content['status'], 'OPEN')
def test_post_comment(self):
i = ItemFactory()
i.save()
r = self.c.post(
self.url,
dict(iid=i.iid,
email=i.assigned_user.userprofile.email,
comment="a comment")
)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content)
self.assertEqual(content['iid'], i.iid)
self.assertEqual(content['status'], 'OPEN')
def test_post_fixed_with_resolve_time(self):
i = ItemFactory()
i.save()
r = self.c.post(
self.url,
dict(status='FIXED',
iid=i.iid,
email=i.assigned_user.userprofile.email,
resolve_time='1 hour',
comment="a comment"))
self.assertEqual(r.status_code, 200)
content = json.loads(r.content)
self.assertEqual(content['iid'], i.iid)
self.assertEqual(content['status'], 'RESOLVED')
def test_post_fixed_with_resolve_time(self):
i = ItemFactory()
i.save()
r = self.c.post(
self.url,
dict(status='FIXED',
iid=i.iid,
email=i.assigned_user.userprofile.email,
resolve_time='1 hour',
comment="a comment")
)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content)
self.assertEqual(content['iid'], i.iid)
self.assertEqual(content['status'], 'RESOLVED')
def setUp(self):
self.c = self.client
self.u = User.objects.create(username="******")
self.u.set_password("test")
self.u.save()
self.c.login(username="******", password="******")
self.item = ItemFactory()
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 setUp(self):
self.u = User.objects.create(username="******")
self.u.set_password("test")
self.u.save()
self.pu = self.u.userprofile
self.item = ItemFactory()
self.n = NotifyFactory(item=self.item, user=self.u)
self.url = reverse("notify", kwargs={'pk': self.n.item.iid})
def test_copy_clients_to_new_item(self):
i = ItemFactory()
c = ClientFactory()
i.add_clients([c])
i2 = ItemFactory()
i.copy_clients_to_new_item(i2)
self.assertTrue(c in [ic.client for ic in i2.itemclient_set.all()])
def test_get_with_interval_params(self):
i = ItemFactory()
p = i.milestone.project
r = self.client.get(
reverse('project-hours-report', args=[p.pid]), {
'format': 'csv',
'interval_start': '2015-12-01',
'interval_end': '2016-02-01',
})
self.assertEqual(r.status_code, 200)
def setUp(self):
self.c = Client()
self.u = User.objects.create(username="******")
self.u.set_password("test")
self.u.save()
self.c.login(username="******", password="******")
pu = PMTUser.objects.create(username="******",
email="*****@*****.**",
status="active")
Claim.objects.create(django_user=self.u, pmt_user=pu)
self.item = ItemFactory()
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_gau(self):
i = ItemFactory()
self.assertEqual(i.get_absolute_url(), "/item/%d/" % i.iid)
def test_target_date_status(self):
now = timezone.now()
i = ItemFactory(target_date=(now + timedelta(days=8)).date())
self.assertEqual(i.target_date_status(), "ok")
i = ItemFactory(target_date=(now + timedelta(days=3)).date())
self.assertEqual(i.target_date_status(), "upcoming")
i = ItemFactory(target_date=(now).date())
self.assertEqual(i.target_date_status(), "due")
i = ItemFactory(target_date=(now - timedelta(days=2)).date())
self.assertEqual(i.target_date_status(), "overdue")
i = ItemFactory(target_date=(now - timedelta(days=80)).date())
self.assertEqual(i.target_date_status(), "late")
def setUp(self):
self.u = User.objects.create(username="******")
self.item = ItemFactory()
self.client.force_authenticate(user=self.u)
def test_status_class(self):
i = ItemFactory()
self.assertEqual(i.status_class(), "dmt-open")
def test_resolved_items_for_interval_with_items(self):
with freeze_time('2013-12-20'):
ItemFactory()
ItemFactory()
i = ItemFactory()
i.resolve(self.u, 'WORKSFORME', 'resolved')
i2 = ItemFactory()
i2.resolve(self.u, 'FIXED', 'done')
i3 = ItemFactory()
i3.verify(self.u, 'verified')
start = datetime(year=2013, month=12, day=16).replace(tzinfo=utc)
end = datetime(year=2013, month=12, day=23).replace(tzinfo=utc)
self.assertEqual(
len(self.u.resolved_items_for_interval(start, end)), 2)
def test_is_bug(self):
i = ItemFactory()
self.assertTrue(i.is_bug())
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_history(self):
i = ItemFactory()
self.assertEqual(i.history(), [])
def test_priority_label(self):
i = ItemFactory()
self.assertEqual(i.priority_label(), 'LOW')
def test_status_display(self):
i = ItemFactory()
self.assertEqual(i.status_display(), 'OPEN')
i.status = 'RESOLVED'
i.r_status = 'FIXED'
self.assertEqual(i.status_display(), 'FIXED')
def test_add_subscriber_active_user(self):
i = ItemFactory()
u = UserProfileFactory()
i.add_subscriber(u)
self.assertEqual(
Notify.objects.filter(item=i.iid, user=u.user).count(), 1)
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_add_clients(self):
i = ItemFactory()
c = ClientFactory()
i.add_clients([c])
self.assertTrue(c in [ic.client for ic in i.itemclient_set.all()])