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 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.user = get_user_model().objects.create_user('a', 'b', 'c')
self.project = Project(creator=self.user,
name="asdf",
name_short="PRJ")
self.project.save()
self.project.manager.add(self.user)
self.project.developer.add(self.user)
self.project2 = Project(creator=self.user,
name="2ndproj",
name_short="PRJ2")
self.project2.save()
self.project2.developer.add(self.user)
self.kanban = KanbanColumn(name='KanCol',
project=self.project2,
position=4)
self.kanban.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()
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 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):
self.user = get_user_model().objects.create_user('a', 'b', 'c')
self.project = Project(name="Fancy Project",
name_short="FYP",
description="Fancy description",
creator=self.user)
self.project.save()
self.project.developer.add(self.user)
self.project2 = Project(name="plain Project",
name_short="plai",
creator=self.user)
self.project2.save()
self.project2.developer.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('invite_users:invite_users')))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
def test_user_passes_test_mixin(self):
proj_name = "project"
proj_short = "cccc"
project = Project(name=proj_name, name_short=proj_short, creator=self.user)
project.save()
proj_name2 = "project2"
proj_short2 = "dddd"
project2 = Project(name=proj_name2, name_short=proj_short2, creator=self.user)
project2.save()
# we neither add the user as manager nor as developer so there are not the necessary rights to manipulate tags
user_doesnt_pass_test_and_gets_404(self, 'tag:tag', address_kwargs={'project': proj_short})
# developer is good
project.developer.add(self.user)
project.save()
response = self.client.get(reverse('tag:tag', kwargs={'project': proj_short}), follow=True)
self.assertNotContains(response, "Your account doesn't have access to this page. To proceed, please " +
"login with an account that has access.")
# manager is good
project2.manager.add(self.user)
project2.save()
response = self.client.get(reverse('tag:tag', kwargs={'project': proj_short2}), follow=True)
self.assertNotContains(response, "Your account doesn't have access to this page. To proceed, please " +
"login with an account that has access.")
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 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('a', 'b', 'c')
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='PRO')
cls.project2.save()
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 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')
self.project.save()
self.project.manager.add(self.user)
self.project.developer.add(self.user)
self.project2 = Project(creator=self.user, name_short='TP')
self.project2.save()
self.project2.manager.add(self.user)
self.project2.developer.add(self.user)
self.column = KanbanColumn(name='Column', position=4, project=self.project)
self.column.save()
def project_index(request):
p1 = Project(title='My First Project',
description='A web development project.',
technology='Django',
image='img/project1.png')
p2 = Project(title='My Second Project',
description='A web development project.',
technology='Django',
image='img/project1.png')
projects = [p1, p2]
context = {'projects': projects}
return render(request, 'project_index.html', context)
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 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')
self.project.save()
self.issue = Issue(title="Test-Issue", project=self.project, type="Bug")
self.issue.save()
def createProject(request):
if request.method == 'POST':
projectName = request.POST.get("projectName", "")
projectDescribe = request.POST.get("projectDescribe", "")
projectStatus = request.POST.get("projectStatus", "")
username = request.session.get('username', "")
userLevel = User.objects.get(username=username)
if userLevel.level == 'visitors':
return JsonResponse({"code": 0, "massage": "权限不足"})
if userLevel.level == 'admin':
project1 = Project()
project1.p_name = projectName
project1.p_describe = projectDescribe
project1.p_status = projectStatus
now = int(time.time())
timeArray = time.localtime(now)
otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
project1.p_createtime = otherStyleTime
project1.p_updatetime = otherStyleTime
project1.p_exists = "True"
print(userLevel.level)
project1.save()
appLog.info(
"log/projectOperation.log",
username + "创建了一个项目：" + projectName + "，项目描述：" +
projectDescribe + "项目状态：" + projectStatus)
return JsonResponse({"code": 200, "massage": "成功"})
else:
return JsonResponse({"code": 0, "massage": "权限不足"})
else:
return JsonResponse({"code": 0, "massage": "请求异常"})
def setUp(self):
self.org = Organization()
self.org.save()
self.project = Project(organization=self.org)
self.project.save()
self.workstream = Workstream(project=self.project)
self.workstream.save()
def save_project_update(request):
if request.method == "POST":
content = request.POST.get('content')
pid = request.POST.get('project')
proj = Project.objects.filter(project_id=pid).select_related()
project = Project()
for item in proj:
project = item
check_project_update = ProjectUpdate.objects.filter(project_id=project)
update = ProjectUpdate()
if check_project_update:
for item in check_project_update:
update = item
update.content = content
update.save()
messages.info(request,
'Project Update has been successfully added')
else:
update.content = content
update.project_id = project
update.save()
messages.info(request,
'Project Update has been successfully added')
return HttpResponseRedirect('/project')
def add_new_project(request):
#user validation start
if not request.user.is_authenticated:
return redirect("/login")
if request.user.user_type == 1:
return redirect("/university/home")
#user validation end
if request.method == 'POST':
form = RegisterProject(request.POST)
if form.is_valid():
admin = Company.objects.get(admin=request.user.pk)
project = Project(
project_name=form.cleaned_data['project_name'],
project_description=form.cleaned_data['project_description'],
developed_for=admin,
start_date=form.cleaned_data['start_date'],
end_date=form.cleaned_data['end_date'],
bidding_start=form.cleaned_data['bidding_start'],
bidding_end=form.cleaned_data['bidding_end'],
)
project.save()
messages.info(
request,
f"Project ' {project.project_name} ' pushed successfully!")
return redirect('/company/home')
# return render(request, 'company/index.html', context)
else:
context = {"form": form}
return render(request, 'company/add_new_project.html', context)
form = RegisterProject()
context = {"form": form}
return render(request, 'company/add_new_project.html', context)
def test_leave_project(self):
new_project = Project(name='asdf', name_short='asd', creator=self.user)
new_project.save()
new_project.manager.add(self.user)
user2 = get_user_model().objects.create_user('test2',
'*****@*****.**',
'test1234')
response = self.client.post(reverse('project:leave',
kwargs={'project': 'asd'}),
{'delete': ''},
follow=True)
self.assertRedirects(
response, reverse('project:edit', kwargs={'project': 'asd'}))
self.assertContains(response, 'last manager')
new_project.developer.add(user2)
response = self.client.post(reverse('project:leave',
kwargs={'project': 'asd'}),
{'delete': ''},
follow=True)
self.assertRedirects(
response, reverse('project:edit', kwargs={'project': 'asd'}))
self.assertContains(response, 'last manager')
new_project.manager.add(user2)
response = self.client.post(reverse('project:leave',
kwargs={'project': 'asd'}),
{'delete': ''},
follow=True)
self.assertRedirects(response, reverse('project:list'))
self.assertNotIn(self.user, new_project.get_members())
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.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 test_renumber_ballot(self):
proj = Project(name='test',
order=0,
doc_type='STD',
description='test_renumber_ballot',
task_group='TGx',
par_date=datetime.datetime.now())
proj.save()
self.failUnlessEqual(Project.objects.count(), 1)
self.failUnlessEqual(Ballot.objects.count(), 0)
bal = Ballot(number=123,
project=proj,
draft='1.0',
opened=datetime.datetime.now(),
pool=100)
bal.closed = bal.opened + datetime.timedelta(days=15)
bal.save()
self.failUnlessEqual(Ballot.objects.count(), 1)
url = reverse('ballot.views.main_page', args=[])
self._check_page(url)
#response = self.client.get(url)
self.wait_for_backlog_completion(DenormalizedBallot, 10)
dn = DenormalizedBallot.objects.get(pk=bal.pk)
bal2 = Ballot.objects.get(number=bal.number)
bal2.number = 321
bal2.save()
Ballot.objects.get(number=123).delete()
self.wait_for_backlog_completion(DenormalizedBallot, 10)
self.failUnlessRaises(DenormalizedBallot.DoesNotExist,
DenormalizedBallot.objects.get,
number=123)
dn = DenormalizedBallot.objects.get(number=bal2.number)
def setUp(self):
# Uses the cookie hack from:
# https://stackoverflow.com/questions/22494583/login-with-code-when-using-liveservertestcase-with-django
client = Client()
self.user = get_user_model().objects.create_user('a', 'b', 'c')
client.login(username='******', password='******')
self.cookie = client.cookies['sessionid']
self.selenium.get("{}{}".format(self.live_server_url, "/"))
self.selenium.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False,
'path': '/'
})
self.selenium.refresh()
self.short = "asdf"
self.project = Project(creator=self.user,
name="long_asdf",
name_short=self.short)
self.project.save()
self.project.developer.set((self.user.pk, ))
self.project.manager.set((self.user.pk, ))
self.project.save()
si = SlackIntegration()
si.project = self.project
si.api_token = "foo"
si.channel = "channel"
si.save()
self.title_name = 'This is title'
self.comment = "This is comment"
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')
self.project.save()
self.project.manager.add(self.user)
self.project.developer.add(self.user)
def test_get_correct_web_submission_link(self):
request = Mock()
request.user = Mock(spec=User)
manager = Mock(spec=DatabaseManager)
manager.database = dict()
raw_project = dict(
value=dict(_id="pid",
devices=["sms", "web"],
activity_report=["no"],
name="Project Name",
created="2012-05-23T02:57:09.788294+00:00",
project_type="survey"))
project = Project(project_type="survey",
entity_type="clinic",
state=ProjectState.ACTIVE)
profile = Mock(spec=NGOUserProfile)
questionnaire = Mock()
questionnaire.form_code = "q01"
with patch("datawinners.project.models.Project.load") as get_project:
get_project.return_value = project
with patch.object(DatabaseManager, "get") as db_manager:
db_manager.return_value = questionnaire
with patch("django.contrib.auth.models.User.get_profile"
) as get_profile:
get_profile.return_value = profile
profile.reporter = False
project_info = get_project_info(manager, raw_project)
self.assertEqual(project_info["web_submission_link"],
"/project/testquestionnaire/pid/")
def setUp(self):
self.base_domain = 'aber.ac.uk'
self.user = CustomUser.objects.create(
username='******'.format(self.base_domain),
email='user@{}'.format(self.base_domain)
)
self.user.save()
self.user2 = CustomUser.objects.create(
username='******'.format(self.base_domain),
email='user2@{}'.format(self.base_domain)
)
self.user2.save()
self.project = Project(
title="Project title",
description="Project description",
tech_lead=self.user,
# category=ProjectCategory.objects.get(pk=1)
)
self.project.save()
self.membership = ProjectUserMembership.objects.create(
user=self.user2, project=self.project, date_joined='2019-07-31'
)
self.membership.save()
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 add_project_save(request):
if request.method != "POST":
messages.error(request, "Invalid Method!")
return redirect('add_project')
else:
form = AddFileForm(request.POST, request.FILES)
if form.is_valid():
p_id = form.cleaned_data['p_id']
title = form.cleaned_data['title']
description = form.cleaned_data['description']
status = form.cleaned_data['status']
if(len(request.FILES) != 0):
report = request.FILES['report']
fs = FileSystemStorage()
filename = fs.save(report.name,report)
report_url = fs.url(filename)
else:
report_url = None
try:
project = Project(p_id = p_id, title = title, description = description, status = status, report = report_url)
project.save()
messages.success(request, "Project Added Successfully!")
return redirect('add_project')
except:
messages.error(request, "Failed to Add Project!!!")
return redirect('add_project')
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()
def test_delete_ballot(self):
proj = Project(name='test',order=0, doc_type='STD', \
description='test_delete_ballot', task_group='TGx', \
par_date=datetime.datetime.now())
proj.save()
bal = Ballot(number=123,project=proj, draft='1.0', \
opened=datetime.datetime.now(), pool=100, \
ballot_type=Ballot.WGInitial.code)
bal.closed = bal.opened + datetime.timedelta(days=15)
bal.save()
self.failUnlessEqual(bal.pk, 123)
self.failUnlessEqual(Ballot.objects.count(), 1)
url = reverse('ballot.views.main_page', args=[])
response = self._check_page(url)
self.failUnlessEqual(Ballot.objects.count(), 1)
self.wait_for_backlog_completion(DenormalizedBallot, 10)
run_test_task_queue(self.client)
self.failUnlessEqual(Ballot.objects.count(), 1)
dn = DenormalizedBallot.objects.get(pk=bal.pk)
self.failIfEqual(dn, None)
self.failUnlessEqual(Ballot.objects.count(), 1)
Ballot.objects.filter(pk=bal.number).delete()
run_test_task_queue(self.client)
self.failUnlessRaises(DenormalizedBallot.DoesNotExist,
DenormalizedBallot.objects.get,
pk=123)
bal = Ballot(number=124,project=proj, draft='2.0', opened=datetime.datetime.now(), \
pool=100, ballot_type=Ballot.WGInitial.code)
bal.closed = bal.opened + datetime.timedelta(days=15)
bal.save()
run_test_task_queue(self.client)
url = reverse('ballot.views.edit_ballot', args=[bal.number])
response = self._check_page(url)
data = response.context['form'].initial
for key in data.keys():
if data[key] is None:
data[key] = ''
data['curpk'] = bal.pk
data['delete'] = 'Delete'
form = BallotForm(data, instance=bal)
valid = form.is_valid()
self.failUnless(valid)
response = self.client.post(url, data)
self.failIf(response.status_code != 302
and response.status_code != 303)
url = reverse('del_ballot', args=[bal.number])
response.get('Location').index(url)
response = self._check_page(url)
match = re.search(r'input\s+type="submit"\s+name="confirm"',
str(response), re.IGNORECASE)
self.assertTrue(match)
data = {"confirm": "Yes, I'm sure"}
response = self.client.post(url, data)
self.failIf(response.status_code != 302
and response.status_code != 303)
self.failUnlessRaises(Ballot.DoesNotExist, Ballot.objects.get, pk=124)
run_test_task_queue(self.client)
self.failUnlessRaises(DenormalizedBallot.DoesNotExist,
DenormalizedBallot.objects.get,
pk=124)
