def test_show_other_user_profile_page(self):
otheruser = get_user_model().objects.create_user('uname', '[email protected]', 'abcd')
sharedproject = Project(creator=self.user, name_short='SPRJ')
sharedproject.save()
sharedproject.developer.add(self.user)
sharedproject.developer.add(otheruser)
notsharedproject = Project(creator=self.user, name_short='NPRJ')
notsharedproject.save()
notsharedproject.developer.add(self.user)
sharedissue = Issue(title='abcd', project=sharedproject)
sharedissue.save()
sharedissue.assignee.add(self.user)
sharedissue.assignee.add(otheruser)
notsharedissue = Issue(title='efgh', project=sharedproject)
notsharedissue.save()
notsharedissue.assignee.add(self.user)
response = self.client.get(reverse('user_profile:user_profile_page', kwargs={"username": otheruser.username}))
self.assertContains(response, otheruser.username)
self.assertContains(response, sharedproject)
self.assertContains(response, sharedissue)
self.assertNotIn(notsharedissue, response.context['sharedissues'])
self.assertNotIn(notsharedproject, response.context['sharedprojects'])
def setUp(self):
self.client.force_login(self.user)
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.project = Project(creator=self.user, name_short='PRJ')
self.project.save()
self.project.developer.add(self.user)
self.project.developer.add(self.user2)
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.kanbancol = KanbanColumn(project=self.project,
position=4,
name='test')
self.kanbancol.save()
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.issue = Issue(
title='a very very very very very very very long issue title',
project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue.save()
self.issue2 = Issue(title='issue title',
project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue2.save()
self.issue.assignee.add(self.user)
def setUp(self):
self.client.force_login(self.user)
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.project = Project(creator=self.user, name_short='PRJ', activity_only_for_managers=False)
self.project.save()
self.project.developer.add(self.user)
self.project2 = Project(creator=self.user, activity_only_for_managers=True, name_short='PRJJ')
self.project2.save()
self.project2.manager.add(self.user)
self.project2.developer.add(self.user, self.user2)
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.kanbancol = KanbanColumn(project=self.project, position=4, name='test')
self.kanbancol.save()
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.issue = Issue(title='a very very very very very very very long issue title',
project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3'
)
self.issue.save()
self.issue.assignee.add(self.user)
self.issue2 = Issue(title='second_issue', project=self.project)
self.issue2.save()
self.issue2.assignee.add(self.user)
self.time = now().strftime("%Y-%m-%d %H:%M:%S")
def setUp(self):
# NOTE: these elements get modified by some testcases, so they should NOT be created in setUpTestData()
self.project = Project(creator=self.user1, name_short='asdf')
self.project.save()
self.project.developer.add(self.user1)
self.project.developer.add(self.user2)
self.project.manager.add(self.user1)
self.project2 = Project(creator=self.user2, name_short='asdg')
self.project2.save()
self.project2.manager.add(self.user2)
self.issue = Issue(title='test', project=self.project)
self.issue.save()
self.issue2 = Issue(title='test', project=self.project2)
self.issue2.save()
self.comment = Comment(text='test', creator=self.user1, issue=self.issue)
self.comment.save()
self.comment2 = Comment(text='test', creator=self.user2, issue=self.issue2)
self.comment2.save()
self.log = Timelog(time=datetime.timedelta(hours=2), user=self.user1, issue=self.issue)
self.log.save()
self.log2 = Timelog(time=datetime.timedelta(hours=2), user=self.user2, issue=self.issue2)
self.log2.save()
self.user1_auth = 'Basic ' + base64.b64encode('user1:c'.encode()).decode()
self.user2_auth = 'Basic ' + base64.b64encode('user2:c'.encode()).decode()
self.client.credentials(HTTP_AUTHORIZATION=self.user1_auth)
def test_stop_sprint_move_issues_to_new_sprint(self):
# self.sprint should not have started
self.assertNotEqual(self.sprint.seqnum, -1)
project = Project(creator=self.user, name_short='APF')
project.save()
project.manager.add(self.user)
sprint = Sprint(project=project)
sprint.save()
self.assertEqual(project.sprint.get_new_sprints().count(), 1)
# columns and issues for testing archiving function
kanbancol1 = KanbanColumn.objects.get(name='Todo', project=project)
kanbancol2 = KanbanColumn.objects.get(name='In Progress', project=project)
kanbancol3 = KanbanColumn.objects.get(name='Done', project=project)
issue = Issue(title="Test-Issue", kanbancol=kanbancol1, project=project, type="Bug", sprint=sprint)
issue.save()
issue2 = Issue(title="Test-Issue2", kanbancol=kanbancol2, project=project, type="Bug", sprint=sprint)
issue2.save()
issue3 = Issue(title="Test-Issue3", kanbancol=kanbancol2, project=project, type="Bug", sprint=sprint)
issue3.save()
issue4 = Issue(title="Test-Issue4", kanbancol=kanbancol3, project=project, type="Bug")
issue4.save()
sprint.set_active()
# move to autocreated sprint
response = self.client.post(reverse('sprint:stopsprint',
kwargs={'project': project.name_short, 'sqn_s': sprint.seqnum}),
{'sprint': 'new', 'move_to_new_sprint': [issue.number, issue2.number]},
follow=True)
# new sprint created
# self.sprint and sprint created during post request
self.assertEqual(project.sprint.all().count(), 2)
self.assertEqual(project.sprint.get_new_sprints().count(), 1)
self.assertEqual(project.sprint.get_old_sprints().count(), 1)
# issue, issue2 in new sprint, issue3 in backlog
self.assertIn(issue, project.sprint.get_new_sprints().last().issue.all())
self.assertIn(issue2, project.sprint.get_new_sprints().last().issue.all())
self.assertNotIn(issue3, project.sprint.get_new_sprints().last().issue.all())
issue3.refresh_from_db()
self.assertEqual(issue3.sprint, None)
# move to existing sprint
sprint = project.sprint.get_new_sprints().last()
sprint.set_active()
project.refresh_from_db()
sprint2 = Sprint(project=project)
sprint2.save()
response = self.client.post(reverse('sprint:stopsprint',
kwargs={'project': project.name_short, 'sqn_s': sprint.seqnum}),
{'sprint': sprint2.seqnum, 'move_to_new_sprint': [issue.number]},
follow=True)
# issue in sprint2, issue2 moved to backlog
self.assertIn(issue, sprint2.issue.all())
self.assertNotIn(issue2, sprint2.issue.all())
issue2.refresh_from_db()
self.assertEqual(issue2.sprint, None)
def setUpTestData(cls):
# NOTE: if you modify those elements they need to be created in setUp, instead of here
cls.user = get_user_model().objects.create_user('a', 'b', 'c')
cls.user2 = get_user_model().objects.create_user('d', 'e', 'f')
cls.project = Project(creator=cls.user, name_short='PRJ')
cls.project.save()
cls.project.developer.add(cls.user)
cls.project2 = Project(creator=cls.user, name_short='PROJ')
cls.project2.save()
cls.project2.developer.add(cls.user)
cls.project2.developer.add(cls.user2)
# create test data (They are needed for search-purpose only)
cls.issue = Issue(title="Test-Issue",
project=cls.project,
kanbancol=cls.project.kanbancol.first(),
type="Bug")
cls.issue.save()
issue = Issue(title="Blub-Issue", project=cls.project, kanbancol=cls.project.kanbancol.first(), type="Bug")
issue.save()
issue = Issue(title="Bla-Issue", project=cls.project, kanbancol=cls.project.kanbancol.first(), type="Task")
issue.save()
cls.issuep2 = Issue(title="Bling-Issue",
project=cls.project2,
kanbancol=cls.project2.kanbancol.first(),
type="Task")
cls.issuep2.due_date = datetime.date(2000, 1, 1)
cls.issuep2.save()
def setUp(self):
self.user = get_user_model().objects.create_user(
'test', '*****@*****.**', 'test')
self.project = Project(creator=self.user, name_short='PRJ')
self.project.save()
self.project.developer.add(self.user)
# NOTE: those elements get modified by some of those tests, so this shall NOT be created in setUpTestData()
self.issue = Issue(title='issue title',
project=self.project,
due_date='2016-12-16',
storypoints='3')
self.issue.save()
self.issue2 = Issue(title='title2',
project=self.project,
due_date='2016-12-16',
storypoints='3')
self.issue2.save()
self.issue.assignee.add(self.user)
# Uses the cookie hack from:
# https://stackoverflow.com/questions/22494583/login-with-code-when-using-liveservertestcase-with-django
client = Client()
client.login(username='******', password='******')
self.cookie = client.cookies['sessionid']
self.selenium.get("{}{}".format(self.live_server_url,
reverse('timelog:loginfo')))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
def setUp(self):
self.user = get_user_model().objects.create_user(
'a_user', '*****@*****.**', 'a1234568')
self.project = Project(name="Projectname",
name_short="proj",
creator=self.user)
self.project.save()
self.project.manager.add(self.user)
self.short = self.project.name_short
tag = Tag(project=self.project, tag_text="foo")
tag.save()
Issue(project=self.project, title="a").save()
issue = Issue(project=self.project, title="b")
issue.save()
issue.tags.add(tag)
# Uses the cookie hack from:
# https://stackoverflow.com/questions/22494583/login-with-code-when-using-liveservertestcase-with-django
client = Client()
client.login(username='******', password='******')
self.cookie = client.cookies['sessionid']
self.selenium.get("{}{}".format(self.live_server_url,
reverse('invite_users:invite_users')))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
def setUp(self):
self.client.force_login(self.user)
# NOTE: these elements get modified by some testcases, so they should NOT be created in setUpTestData()
self.project = Project(creator=self.user, name_short='PRJ', activity_only_for_managers=False)
self.project.save()
self.project.developer.add(self.user)
self.project2 = Project(creator=self.user, activity_only_for_managers=True, name_short='PRJJ')
self.project2.save()
self.project2.manager.add(self.user)
self.project2.developer.add(self.user, self.user2)
self.kanbancol = KanbanColumn(project=self.project, position=4, name='test')
self.kanbancol.save()
self.issue = Issue(title='a very very very very very very very long issue title',
project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3'
)
self.issue.save()
self.issue.assignee.add(self.user)
self.issue2 = Issue(title='second_issue', project=self.project)
self.issue2.save()
self.issue2.assignee.add(self.user)
self.time = now().strftime("%Y-%m-%d %H:%M:%S")
# success logedit_address_kwargs
self.sqn_l1_address_kwarg = {"project": self.issue.project.name_short,
"sqn_i": self.issue.number,
"sqn_l": 1
}
def test_board_order_by(self):
# driver.find_element_by_id("dropdownMenu1").click()
# driver.find_element_by_link_text("Sprint 1").click()
# create project and issues
driver = self.selenium
project = Project(name='TestProjekt', name_short='TP', creator=self.user)
project.save()
project.developer.add(self.user)
issue1 = Issue(project=project, title="TestIssue1", priority=4, type='Story')
issue2 = Issue(project=project, title="TestIssue2", priority=0, type='Bug')
issue3 = Issue(project=project, title="TestIssue3", priority=3, type='Task')
issue4 = Issue(project=project, title="TestIssue3", priority=2, type='Task')
issue5 = Issue(project=project, title="TestIssue3", priority=0, type='Story')
issue1.save()
issue2.save()
issue3.save()
issue4.save()
issue5.save()
# check order_by number
driver.get("{}{}".format(self.live_server_url, reverse('sprint:sprintboard',
kwargs={'project': project.name_short}
)))
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
for i in range(len(issues)-1):
self.assertEqual(issues[i].get_attribute("id") < issues[i+1].get_attribute("id"), True)
# check order_by priority
driver.get("{}{}".format(self.live_server_url, reverse('sprint:sprintboard',
kwargs={'project': project.name_short}
))+"?order_by=priority")
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
for i in range(len(issues)-1):
self.assertEqual(issues[i].get_attribute("data-priority") >= issues[i+1].get_attribute("data-priority"),
True)
# check order_by title
driver.get("{}{}".format(self.live_server_url, reverse('sprint:sprintboard',
kwargs={'project': project.name_short}
))+"?order_by=title")
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
for i in range(len(issues)-1):
self.assertEqual(issues[i].get_attribute("data-title") <= issues[i+1].get_attribute("data-title"), True)
# check order_by Type
driver.get("{}{}".format(self.live_server_url, reverse('sprint:sprintboard',
kwargs={'project': project.name_short}
))+"?order_by=type")
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
for i in range(len(issues)-1):
self.assertEqual(issues[i].get_attribute("data-type") <= issues[i+1].get_attribute("data-type"), True)
def test_sprints_and_issues_in_archive_view(self):
newsprint = Sprint(project=self.project)
newsprint.save()
startedsprint = Sprint(project=self.project,
startdate=datetime.datetime.now())
startedsprint.save()
stoppedsprint = Sprint(project=self.project,
startdate=datetime.datetime.now(),
enddate=datetime.datetime.now())
stoppedsprint.save()
wrongsprint = Sprint(project=self.project,
enddate=datetime.datetime.now())
wrongsprint.save()
issueinnew = Issue(title="boo",
project=self.project,
sprint=newsprint,
archived=True)
issueinnew.save()
issueinstarted = Issue(title="coo",
project=self.project,
sprint=startedsprint,
archived=True)
issueinstarted.save()
issueinstopped = Issue(title="doo",
project=self.project,
sprint=stoppedsprint,
archived=True)
issueinstopped.save()
issueinwrong = Issue(title="foo",
project=self.project,
sprint=wrongsprint,
archived=True)
issueinwrong.save()
issueinno = Issue(title="goo", project=self.project, archived=True)
issueinno.save()
response = self.client.get(
reverse('archive:archive',
kwargs={'project': self.project.name_short}))
self.assertNotIn(issueinnew,
response.context['archived_issues_without_sprint'])
self.assertNotIn(issueinwrong,
response.context['archived_issues_without_sprint'])
self.assertNotIn(issueinstopped,
response.context['archived_issues_without_sprint'])
self.assertNotIn(issueinstarted,
response.context['archived_issues_without_sprint'])
self.assertIn(issueinno,
response.context['archived_issues_without_sprint'])
self.assertEqual(response.context['sprints_sorted'].all()[0],
wrongsprint)
self.assertEqual(response.context['sprints_sorted'].all()[1],
stoppedsprint)
self.assertEqual(response.context['sprints_sorted'].all()[2],
startedsprint)
self.assertEqual(response.context['sprints_sorted'].all()[3],
newsprint)
def test_board_filter_my_issues(self):
driver = self.selenium
project = Project(name='TestProjekt',
name_short='TP',
creator=self.user)
project.save()
project.developer.add(self.user)
issue1 = Issue(project=project,
title="TestIssue1",
priority=4,
type='Story')
issue2 = Issue(project=project,
title="TestIssue2",
priority=0,
type='Bug')
issue3 = Issue(project=project,
title="TestIssue3",
priority=3,
type='Task')
issue4 = Issue(project=project,
title="TestIssue3",
priority=2,
type='Task')
issue5 = Issue(project=project,
title="TestIssue3",
priority=0,
type='Story')
issue1.save()
issue2.save()
issue3.save()
issue4.save()
issue5.save()
driver.get("{}{}".format(
self.live_server_url,
reverse('sprint:sprintboard',
kwargs={'project': project.name_short})))
# 5 issues in col 0
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
self.assertEqual(len(issues), 5)
issue1.assignee.add(self.user)
driver.get("{}{}".format(
self.live_server_url,
reverse('sprint:sprintboard',
kwargs={'project': project.name_short})) +
"?myissues=true")
# 1 issue in col 0
col = driver.find_element_by_id("sortable0")
issues = col.find_elements_by_class_name("issuecard")
self.assertEqual(len(issues), 1)
def setUp(self):
self.user = get_user_model().objects.create_user('a', 'b', 'c')
self.user.last_name = 'Issue'
self.user.save()
# Uses the cookie hack from:
# https://stackoverflow.com/questions/22494583/login-with-code-when-using-liveservertestcase-with-django
client = Client()
client.login(username='******', password='******')
self.cookie = client.cookies['sessionid']
self.selenium.get('{}{}'.format(self.live_server_url,
reverse('landing_page:home')))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
# project: user is manager
self.project = Project(creator=self.user,
name="asdf",
description='project for fancy issues',
name_short="PRJ")
self.project.save()
self.project.developer.add(self.user)
self.project.manager.add(self.user)
self.projiss1 = Issue(title="Issue for Proj1",
project=self.project,
kanbancol=self.project.kanbancol.first(),
type="Task")
self.projiss1.save()
self.projiss2 = Issue(title="Another Issue for Proj1",
project=self.project,
kanbancol=self.project.kanbancol.first(),
type="Bug")
self.projiss2.save()
# project2: user is developer
self.project2 = Project(creator=self.user,
name="2ndproj",
name_short="PRJ2")
self.project2.save()
self.project2.developer.add(self.user)
# project2: user is neither developer nor manager
self.project3 = Project(creator=self.user,
name="3rdproj",
name_short="PRJ3")
self.project3.save()
self.proj2iss1 = Issue(title="Issue for Proj2",
project=self.project2,
kanbancol=self.project2.kanbancol.first(),
type="Bug")
self.proj2iss1.save()
def create_some_issues(self):
col = KanbanColumn.objects.filter(project=self.project)
col2 = KanbanColumn.objects.filter(project=self.project2)
iss = []
iss.append(Issue(title='asd', kanbancol=col.get(pk=1), priority=0, type='Bug', project=self.project))
iss.append(Issue(title='asd2', kanbancol=col.get(pk=2), priority=1, type='Story', project=self.project))
iss.append(Issue(title='asd3', kanbancol=col.get(pk=3), priority=2, type='Task', project=self.project))
iss.append(Issue(title='asd4', kanbancol=col.get(pk=3), priority=3, archived=True, project=self.project))
iss.append(Issue(title='asd5', kanbancol=col2.first(), priority=4, project=self.project2))
for issue in iss:
issue.save()
issue.assignee.add(self.user)
return iss
def setUp(self):
self.client.force_login(self.user)
# NOTE: these elements get modified by some testcases, so they should NOT be created in setUpTestData()
self.issue = Issue(project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue.save()
self.issue2 = Issue(project=self.project2,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue2.save()
def setUpTestData(cls):
# NOTE: if you modify these elements they need to be created in setUp(), instead of here
cls.user = get_user_model().objects.create_user('test', '*****@*****.**', 'test1234')
cls.project = Project(creator=cls.user, name_short='PRJ')
cls.project.save()
cls.project.developer.add(cls.user)
cls.kanbancol = KanbanColumn(project=cls.project, position=4, name='test')
cls.kanbancol.save()
cls.issue = Issue(project=cls.project, due_date='2016-12-16', kanbancol=cls.kanbancol, storypoints='3')
cls.issue.save()
cls.issue2 = Issue(project=cls.project, due_date='2016-12-16', kanbancol=cls.kanbancol, storypoints='3')
cls.time = timezone.now().replace(microsecond=100000)
cls.timestamp = cls.time.timestamp()
def setUp(self):
self.client.force_login(self.user)
# NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
self.issue = Issue(project=self.project,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue.save()
self.issue2 = Issue(project=self.project2,
due_date='2016-12-16',
kanbancol=self.kanbancol,
storypoints='3')
self.issue2.save()
def test_sprint_functions(self):
# sprint is new sprint
self.assertTrue(self.sprint in Sprint.objects.get_new_sprints())
self.assertFalse(self.sprint in Sprint.objects.get_current_sprints())
self.assertFalse(self.sprint in Sprint.objects.get_old_sprints())
# set sprint active
self.sprint.set_active()
self.assertTrue(self.sprint.is_active)
# sprint is new current sprint
self.assertFalse(self.sprint in Sprint.objects.get_new_sprints())
self.assertTrue(self.sprint in Sprint.objects.get_current_sprints())
self.assertFalse(self.sprint in Sprint.objects.get_old_sprints())
# done and undone issue to put back in backlog
kanbancoldone = KanbanColumn.objects.get(type='Done',
project=self.project)
kanbancolprogress = KanbanColumn.objects.get(type='InProgress',
project=self.project)
issuedone = Issue(title="Test-Issue",
kanbancol=kanbancoldone,
project=self.project,
type="Bug",
sprint=self.sprint)
issuedone.save()
issueprogress = Issue(title="Test-Issue",
kanbancol=kanbancolprogress,
project=self.project,
type="Bug",
sprint=self.sprint)
issueprogress.save()
# set sprint inactive
issueleft = self.sprint.set_inactive()
self.assertTrue(self.sprint.is_inactive())
issuedone.refresh_from_db()
issueprogress.refresh_from_db()
# issues are right archived and assigned
self.assertTrue(issueleft)
self.assertTrue(issuedone.archived)
self.assertFalse(issueprogress.archived)
self.assertIsNotNone(issuedone.sprint)
self.assertIsNone(issueprogress.sprint)
self.assertTrue(issueprogress.was_in_sprint)
# sprint is new old sprint
self.assertFalse(self.sprint in Sprint.objects.get_new_sprints())
self.assertFalse(self.sprint in Sprint.objects.get_current_sprints())
self.assertTrue(self.sprint in Sprint.objects.get_old_sprints())
def test_dependencies(self):
driver = self.selenium
# create two issues
issue = Issue(title="title",
kanbancol=KanbanColumn.objects.get(project=self.project,
name="Todo"),
due_date=str(datetime.date.today()),
priority=3,
storypoints=2,
description="blubber",
project=self.project)
issue.save()
issue.assignee.add(self.user)
issue = Issue(title="title",
kanbancol=KanbanColumn.objects.get(project=self.project,
name="Todo"),
due_date=str(datetime.date.today()),
priority=3,
storypoints=2,
description="blubber",
project=self.project)
issue.save()
issue.assignee.add(self.user)
driver.get('{}{}'.format(
self.live_server_url,
reverse('backlog:backlog',
kwargs={'project': self.project.name_short})))
driver.find_element_by_link_text("PRJ-1").click()
driver.find_element_by_id("issue_detail_edit_link").click()
driver.find_element_by_xpath("(//input[@type='search'])[2]").send_keys(
'\n')
time.sleep(1)
self.assertEqual(
len(
driver.find_elements_by_css_selector(
'#select2-id_dependsOn-results li')), 1)
for i in driver.find_elements_by_css_selector(
'#select2-id_dependsOn-results li'):
i.click()
driver.find_element_by_id("id_submit_edit").click()
self.assertIn('Depends on', driver.page_source)
self.assertIn('PRJ-2', driver.page_source)
url = driver.current_url
driver.find_element_by_link_text("title").click()
self.assertIn('Dependent issues', driver.page_source)
self.assertIn('PRJ-1', driver.page_source)
driver.find_element_by_link_text("title").click()
self.assertEqual(url, driver.current_url)
def test_dont_assign_issues_to_stoped_sprints(self):
issue = Issue(title="Test-Issue", project=self.project, type="Bug")
issue.save()
issue2 = Issue(title="Test-Issue2", project=self.project, type="Bug")
issue2.save()
# start sprint
self.sprint.set_active()
self.sprint.save()
self.project.currentsprint = self.sprint
self.project.save()
# assign first issue
response = self.client.post(reverse('sprint:assigntosprint', kwargs={'project': self.project.name_short}),
{'sqn_i': issue.number}, follow=True,
HTTP_REFERER=reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertRedirects(response, reverse('backlog:backlog', kwargs={'project': self.project.name_short,
'sqn_s': self.sprint.seqnum}))
# first issue is part of the sprint
issue.refresh_from_db()
self.assertIsNotNone(issue.sprint)
# stop sprint
response = self.client.post(reverse('sprint:stopsprint',
kwargs={'project': self.project.name_short, 'sqn_s': self.sprint.seqnum}),
{'sprint': 'new', 'move_to_new_sprint': []},
follow=True)
self.assertEqual(Issue.objects.get(pk=issue.pk).was_in_sprint, True)
# assign second issue => should fail
response = self.client.post(reverse('sprint:assigntosprint', kwargs={'project': self.project.name_short}),
{'sqn_i': issue2.number}, follow=True,
HTTP_REFERER=reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertRedirects(response, reverse('backlog:backlog', kwargs={'project': self.project.name_short}))
# second issue is NOT part of the sprint
issue2.refresh_from_db()
self.assertIsNone(issue2.sprint)
# create new sprint - so we don't run into the not-sprint part but really into the atomic check for enddate
sprint2 = Sprint(project=self.project)
sprint2.save()
response = self.client.post(reverse('sprint:assigntosprint', kwargs={'project': self.project.name_short}),
{'sqn_i': issue2.number}, follow=True,
HTTP_REFERER=reverse('backlog:backlog', kwargs={'project': self.project.name_short,
'sqn_s': self.sprint.seqnum}))
self.assertRedirects(response, reverse('backlog:backlog', kwargs={'project': self.project.name_short,
'sqn_s': self.sprint.seqnum}))
issue2.refresh_from_db()
self.assertIsNone(issue2.sprint)
def test_get_issues(self):
response = self.client.get(reverse('api:issues-list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json().get('count'), 0)
issue = Issue(title='asdf', project=self.project)
issue.save()
issue.assignee.add(self.user1)
response = self.client.get(reverse('api:issues-list'))
self.assertEqual(response.json().get('count'), 1)
issue = Issue(title='asdf2', project=self.project)
issue.save()
issue.assignee.add(self.user2)
response = self.client.get(reverse('api:issues-list'))
self.assertEqual(response.json().get('count'), 1)
def test_storypoints_in_backlog(self):
kanbancol = KanbanColumn(name='Column',
position=1,
project=self.project)
kanbancol.save()
issue = Issue(title="Test-Issue",
kanbancol=kanbancol,
project=self.project,
type="Bug",
sprint=self.sprint)
issue.save()
response = self.client.get(
reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertNotContains(response, 'Storypoints:')
issue.storypoints = 5
issue.save()
response = self.client.get(
reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertNotContains(response, 'Storypoints:')
issue.assignee.add(self.user)
response = self.client.get(
reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertContains(response, 'Storypoints:')
self.assertContains(response, str(self.user.username) + ': 5')
user2 = get_user_model().objects.create_user('a2', 'b2', 'c2')
user2.save()
self.project.developer.add(user2)
issue.assignee.add(user2)
response = self.client.get(
reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertContains(response, str(user2.username) + ': 2.5')
self.assertContains(response, str(self.user.username) + ': 2.5')
issue2 = Issue(title="Test-Issue",
kanbancol=kanbancol,
project=self.project,
type="Bug",
sprint=self.sprint,
storypoints=5)
issue2.save()
issue2.assignee.add(self.user)
response = self.client.get(
reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertContains(response, str(user2.username) + ': 2.5')
self.assertContains(response, str(self.user.username) + ': 7.5')
def test_managerfunctions(self):
issue1 = Issue(title="issue1",
project=self.project,
kanbancol=self.column)
issue1.save()
sprint_current = Sprint(project=self.project,
startdate=(timezone.now() - timedelta(days=1)))
sprint_current.save()
sprint_old = Sprint(project=self.project,
startdate=(timezone.now() - timedelta(days=14)),
enddate=(timezone.now() - timedelta(days=1)))
sprint_old.save()
issues_wo_sprint = Issue.objects.without_sprint()
self.assertTrue(issue1 in issues_wo_sprint)
issue1.sprint = sprint_current
issue1.save()
issues_cur_sprint = Issue.objects.current_sprint()
self.assertTrue(issue1 in issues_cur_sprint)
issue1.sprint = sprint_old
issue1.save()
issues_cur_sprint = Issue.objects.current_sprint()
issues_wo_sprint = Issue.objects.without_sprint()
self.assertFalse(issue1 in issues_cur_sprint)
self.assertFalse(issue1 in issues_wo_sprint)
def test_add_and_remove_issue_from_sprint(self):
kanbancol = KanbanColumn(name='Column', position=1, project=self.project)
kanbancol.save()
issue = Issue(title="Test-Issue", kanbancol=kanbancol, project=self.project, type="Bug")
issue.save()
# add to sprint
response = self.client.post(reverse('sprint:assigntosprint', kwargs={'project': self.project.name_short}),
{'sqn_i': issue.number}, follow=True,
HTTP_REFERER=reverse('backlog:backlog',
kwargs={'project': self.project.name_short}))
self.assertRedirects(response, reverse('backlog:backlog', kwargs={'project': self.project.name_short,
'sqn_s': self.sprint.seqnum}))
self.assertEqual(Issue.objects.get(pk=issue.pk).sprint, Sprint.objects.get(pk=self.sprint.pk))
# remove from sprint
response = self.client.post(reverse('sprint:assigntosprint', kwargs={'project': self.project.name_short}),
{'sqn_s': self.sprint.seqnum, 'sqn_i': issue.number}, follow=True,
HTTP_REFERER=reverse('backlog:backlog', kwargs={'project': self.project.name_short})
)
self.assertRedirects(response, reverse('backlog:backlog', kwargs={'project': self.project.name_short,
'sqn_s': self.sprint.seqnum}))
self.assertEqual(Issue.objects.get(pk=issue.pk).sprint, None)
def test_comment(self, slackmock):
issue = Issue()
issue.title = self.title_name
issue.project = self.project
issue.save()
self.selenium.get(
'{}{}'.format(
self.live_server_url,
reverse('issue:detail', kwargs={'project': self.project.name_short, 'sqn_i': issue.number})
)
)
f = self.selenium.find_element_by_id("id_text")
f.send_keys(self.comment)
self.selenium.find_element_by_name("action").click()
slackmock().api_call.assert_called_with(
"chat.postMessage",
channel="channel",
attachments=[{
'fallback': str(self.user) + ' commented on \"'+self.short+'-1 '+self.title_name+'\".',
'pretext': 'New comment:',
'text': self.comment,
'title': self.short+"-1 "+self.title_name,
'title_link': "http://localhost:8000/project/"+self.short+"/issue/1/",
'author_name': str(self.user),
'author_link': "http://localhost:8000" + self.user.get_absolute_url(),
'author_icon': "http://localhost:8000" + self.user.avatar.url,
'color': 'good',
}]
)
def test_comment_delete(self):
# create sample issue
issue = Issue(title="Test-Issue",
project=self.project,
kanbancol=self.column,
type="Bug")
issue.save()
# create sample comment
comment = Comment(text="Test Comment", creator=self.user, issue=issue)
comment.save()
# delete the comment
response = self.client.get(reverse('issue:delete_comment',
kwargs={
'project':
self.project.name_short,
'sqn_i': issue.number,
'pk_c': comment.pk
}),
follow=True)
self.assertRedirects(
response,
reverse('issue:detail',
kwargs={
'project': self.project.name_short,
'sqn_i': issue.number
}))
self.assertFalse(issue.comments.all().exists())
def test_number_kanbancolumns_for_case_not_default(self):
driver = self.selenium
issue = Issue(title="title", kanbancol=KanbanColumn.objects.get(project=self.project, name="Todo"),
due_date=str(datetime.date.today()), priority=3, storypoints=2, description="blubber",
project=self.project
)
issue.save()
issue.assignee.add(self.user)
driver.get("{}{}".format(self.live_server_url, reverse('issue:create',
kwargs={'project': self.project2.name_short})))
driver.find_element_by_id("id_title").send_keys("title")
# assert that 2nd project has one kanban col more
self.assertEqual(len(Select(driver.find_element_by_id("id_kanbancol")).options), 5)
# assert that dependsOn now has one entry
driver.get('{}{}'.format(self.live_server_url, reverse('backlog:backlog',
kwargs={'project': self.project.name_short}
)))
driver.find_element_by_link_text("New issue").click()
driver.find_element_by_xpath("(//input[@type='search'])[2]").send_keys('\n')
time.sleep(1)
self.assertEqual(len(driver.find_elements_by_css_selector('#select2-id_dependsOn-results li')), 1)
for i in driver.find_elements_by_css_selector('#select2-id_dependsOn-results li'):
self.assertIn("title", i.text)
def test_issue_modify(self, slackmock):
issue = Issue()
issue.title = self.title_name
issue.project = self.project
issue.save()
self.selenium.get(
'{}{}'.format(
self.live_server_url,
reverse('issue:edit', kwargs={'project': self.short, 'sqn_i': issue.number})
)
)
f = self.selenium.find_element_by_css_selector("input.select2-search__field").click()
time.sleep(1)
self.selenium.find_elements_by_css_selector('#select2-id_assignee-results li')[0].click()
self.selenium.find_element_by_id('id_submit_edit').click()
slackmock().api_call.assert_called_with(
"chat.postMessage",
channel="channel",
attachments=[{
'fallback': str(self.user) + " changed issue "+self.short+"-1 "+self.title_name+".",
'pretext': 'Issue changed:',
'title': self.short+"-1 "+self.title_name,
'title_link': "http://localhost:8000/project/"+self.short+"/issue/1/",
'author_name': str(self.user),
'author_link': "http://localhost:8000" + self.user.get_absolute_url(),
'author_icon': "http://localhost:8000" + self.user.avatar.url,
'fields': [{
'title': 'Assignee',
'value': ' → a',
'short': True,
}],
'color': 'good',
}]
)
def test_edit_same_settings_as_set(self):
driver = self.selenium
issue = Issue(title="title",
kanbancol=KanbanColumn.objects.get(project=self.project,
name="Todo"),
due_date=str(datetime.date.today()),
priority=3,
storypoints=2,
description="blubber",
project=self.project)
issue.save()
issue.assignee.add(self.user)
driver.get("{}{}".format(
self.live_server_url,
reverse('issue:edit',
kwargs={
'project': self.project.name_short,
'sqn_i': issue.number
})))
self.assertEqual(
len(Select(driver.find_element_by_id("id_kanbancol")).options), 4)
# issue must not depend on itself
driver.find_element_by_xpath("(//input[@type='search'])[2]").send_keys(
'\n')
time.sleep(1)
self.assertEqual(
len(
driver.find_elements_by_css_selector(
'#select2-id_dependsOn-results li')), 1)
for i in driver.find_elements_by_css_selector(
'#select2-id_dependsOn-results li'):
self.assertEqual(i.text, "No results found")
def setUp(self):
self.user = get_user_model().objects.create_user('a', 'b', 'c')
self.user2 = get_user_model().objects.create_user('d', 'e', 'f')
self.project = Project(creator=self.user,
name="Selenium-Project",
name_short="SLN")
self.project.save()
self.project.developer.add(self.user)
self.project.developer.add(self.user2)
self.project.manager.add(self.user)
self.issue = Issue(title="Test-Issue",
project=self.project,
kanbancol=self.project.kanbancol.first(),
type="Bug")
self.issue.save()
# Uses the cookie hack from:
# https://stackoverflow.com/questions/22494583/login-with-code-when-using-liveservertestcase-with-django
client = Client()
client.login(username='******', password='******')
self.cookie = client.cookies['sessionid']
self.selenium.get("{}{}".format(self.live_server_url,
reverse('invite_users:invite_users')))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
