def create(request):
if request.method == 'POST':
try:
name = request.POST['name']
description = request.POST['description']
lat = request.POST['latitude']
lng = request.POST['longitude']
except:
raise Http404
issue = Issue()
issue.name = name
issue.description = description
logging.debug('Debug latitude')
issue.latitude = lat
issue.longitude= lng
issue.save()
try:
logging.debug('Saving issue')
issue.save()
# send email
issue.new_issue_email()
except:
raise Http404
return render(request, 'issues/show.html', {'issue': issue})
def test_create_proposal(self):
i = Issue(community=self.community, title="Issue ABC",
created_by=self.chairmen[0])
i.full_clean()
i.save()
title = 'Proposal XYZ'
content = 'hellow world'
self.assertEquals(0, Proposal.objects.count())
self.login_chairmen()
url = reverse('proposal_create', args=(self.community.id, i.id))
response = self.client.get(url)
self.assertEquals(200, response.status_code)
response = self.client.post(url, {
'proposal-type': ProposalType.RULE,
'proposal-title': title,
'proposal-content': content,
'proposal-tags': 'tag1,tag2,tag3',
})
self.assertEquals(200, response.status_code)
# Ajax call returns a partial html
self.assertEquals(1, Proposal.objects.count())
p = Proposal.objects.all()[0]
assert isinstance(p, Proposal)
self.assertContains(response, p.get_absolute_url())
self.assertEquals(title, p.title)
self.assertEquals(content, p.content)
def testIssueNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
def testIssueNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
def test_get_add_vote_to_cart(self):
feature = Issue(
issue_type='feature',
title='new feature 1',
description='this will be great',
author=self.user,
)
feature.save()
response = self.client.get(
reverse('add_vote_to_cart', args=[feature.id]))
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('view_cart'))
def create_issue(request, issue_state):
data=None
if issue_state =='create':
data={
'issue_form': IssueForm(),
'issue_create':'active',
'page_title':'Create Issue',
'system_name':'Create Issue',
}
elif issue_state =='save':
if request.method == 'POST':
iss_form = IssueForm(request.POST, request.FILES)
if iss_form.is_valid():
dt = datetime.datetime.now()
curr=request.user
if not Issue.objects.filter(title__iexact=iss_form.cleaned_data['title'] ).exists():
issue_meta = Issue(
issue_volume = int(iss_form.cleaned_data['issue_volume']),
issue_number = int(iss_form.cleaned_data['issue_number']),
issue_year = iss_form.cleaned_data['issue_year'],
title = iss_form.cleaned_data['title'],
description = iss_form.cleaned_data['description'],
printIssn = iss_form.cleaned_data['printIssn'],
is_published = False,
# special_issue = models.BooleanField(default = False)
)
issue_meta.save()
if 'cover_photo' in request.FILES:
# print(request.FILES['image_path'])
issue_meta.cover_photo = request.FILES['cover_photo']
issue_meta.save()
request.session['issue_saved'] = issue_meta.id
else:
request.session['issue_saved'] = 0
return HttpResponseRedirect('/joumsy/issues_view/not_published')
else:
print('not post')
# json_response = json.dumps(data)
# return HttpResponse(json_response, content_type="application/json")
return render(request,'journals/index_issue.html', data)
def update_local_issue(
gr_issue,
id_namespace='',
service_namespace='',
):
"""
:param gr_issue: GeoReportv2 Issue structure (as a dict)
:param id_namespace: String to prepend to request identifiers
:param service_namespace: String to prepend to service codes
:return: The created/updated Issue and a `created` flag
"""
gr_issue = deepcopy(gr_issue)
identifier = gr_issue.pop('service_request_id')
if id_namespace:
identifier = '%s:%s' % (id_namespace, identifier)
issue = Issue.objects.filter(identifier=identifier).first()
if not issue:
issue = Issue(identifier=identifier)
created = True
else:
created = False
for field in Issue._meta.get_fields():
if field.name in gr_issue:
value = gr_issue.pop(field.name)
if isinstance(field, DateTimeField):
value = parse_date(value)
setattr(issue, field.attname, value)
if "long" in gr_issue and "lat" in gr_issue:
issue.location = GEOSGeometry(
'SRID=4326;POINT(%s %s)' %
(gr_issue.pop('long'), gr_issue.pop('lat')))
if 'service_code' in gr_issue:
gr_issue['service_code'] = '%s%s' % (service_namespace,
gr_issue['service_code'])
# This has no direct mapping in our schema, but it can be used by implicit autocreation of services
issue.service_name = gr_issue.pop('service_name', None)
issue._cache_data()
issue.full_clean()
issue.save()
extended_attributes = gr_issue.pop('extended_attributes', {})
for ex_class in get_extensions():
ex = ex_class()
ex.parse_extended_attributes(issue, extended_attributes)
if gr_issue:
print(gr_issue)
issue.source = gr_issue
return (issue, created)
def resource_report(request,
object_id,
template_name='depot/resource_report.html'):
"""
View for reporting a report when a user finds a problem with it.
"""
resource = get_one_or_404(Resource, id=ObjectId(object_id))
reporter = get_account(request.user.id)
# if 'next' in request.GET:
# url = request.GET['next']
# else:
# url = None
# url = url or reverse('resource', args=[resource.id])
if Issue.objects(reporter=reporter, related_document=resource).count():
messages.warning(request, 'You have already reported this resource.')
return HttpResponseRedirect(reverse('resource', args=[resource.id]))
if request.method == 'POST':
form = ResourceReportForm(request.POST)
if form.is_valid():
severity = int(form.cleaned_data['severity'])
message = form.cleaned_data['message']
issue = Issue(message=message,
severity=severity,
reporter=reporter)
issue.related_document = resource
issue.save()
issue.notify_created()
# only moderate as STATUS_BAD if SEVERITY_CRITICAL
if severity == SEVERITY_CRITICAL:
resource.moderate_as_bad(reporter)
return HttpResponseRedirect(
reverse('issue_detail', args=[issue.id]))
else:
form = ResourceReportForm()
return render_to_response(
template_name, {
'next': urlquote_plus(request.GET.get('next', '')),
'form': form,
'object': resource,
}, RequestContext(request))
def test_vote_proposal(self):
# p = self.test_create_proposal()
######################################
i = Issue(community=self.community, title="Issue ABC",
created_by=self.chairmen[0])
i.full_clean()
i.save()
title = 'Proposal XYZ'
content = 'hellow world'
p = Proposal.objects.create(type=ProposalType.RULE, issue=i, created_by=self.chairmen[0], title=title, content=content)
######################################
#TODO: create this via HTML request
pv = ProposalVote(proposal=p, user=self.members[0], value=ProposalVoteValue.CON)
pv.full_clean()
pv.save()
return pv
def test_get_or_create_anonymously(self):
client = self.client
# get get_or_create page
response = client.get(reverse('issues.views.get_or_create',
kwargs={'task_id': self.task.id, 'student_id': self.student.id}))
self.assertEqual(response.status_code, 302, "Need login for get_or_create")
issue = Issue()
issue.student = self.student
issue.task = self.task
issue.save()
# get issue_page page
response = client.get(reverse('issues.views.issue_page',
kwargs={'issue_id': issue.id}))
self.assertEqual(response.status_code, 302, "Need login for issue_page")
def handle(self, count, service, min_lat=None, max_lat=None, min_lon=None, max_lon=None, **options):
service = Service.objects.get(service_code=service)
for i in range(count):
lat = long = None
if min_lat and max_lat and min_lon and max_lon:
lat = random.uniform(min_lat, max_lat)
long = random.uniform(min_lon, max_lon)
issue = Issue(
service=service,
lat=lat,
long=long,
submitter_email='*****@*****.**',
description=generate_description(),
)
issue.save()
self.stdout.write('{} issues created'.format(count))
def resource_report(request, object_id, template_name='depot/resource_report.html'):
"""
View for reporting a report when a user finds a problem with it.
"""
resource = get_one_or_404(Resource, id=ObjectId(object_id))
reporter=get_account(request.user.id)
# if 'next' in request.GET:
# url = request.GET['next']
# else:
# url = None
# url = url or reverse('resource', args=[resource.id])
if Issue.objects(reporter=reporter, related_document=resource).count():
messages.warning(request, 'You have already reported this resource.')
return HttpResponseRedirect(reverse('resource', args=[resource.id]))
if request.method == 'POST':
form = ResourceReportForm(request.POST)
if form.is_valid():
severity=int(form.cleaned_data['severity'])
message=form.cleaned_data['message']
issue = Issue(
message=message,
severity=severity,
reporter=reporter)
issue.related_document = resource
issue.save()
issue.notify_created()
# only moderate as STATUS_BAD if SEVERITY_CRITICAL
if severity == SEVERITY_CRITICAL:
resource.moderate_as_bad(reporter)
return HttpResponseRedirect(reverse('issue_detail', args=[issue.id]))
else:
form = ResourceReportForm()
return render_to_response(template_name, {
'next': urlquote_plus(request.GET.get('next', '')),
'form': form,
'object': resource,
}, RequestContext(request))
class IssueModel(TestCase):
def setUp(self) -> None:
self.issue = Issue(
number=1,
name='any title',
body='any body',
main_language=ProgrammingLanguage.get_other_default_language(),
repository=Repository.objects.create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.create(owner='carlosmaniero')))
self.issue.save()
def test_by_default_the_rate_level_is_not_rated(self):
self.assertEquals(self.issue.rate_label, 'Not rated yet')
def test_it_rates_the_issue_as_very_easy(self):
self.issue.rate(1)
self.assertEquals(self.issue.rate_label, 'Very Easy')
def test_it_rates_the_issue_as_easy(self):
self.issue.rate(2)
self.assertEquals(self.issue.rate_label, 'Easy')
def test_it_rates_the_issue_as_medium(self):
self.issue.rate(3)
self.assertEquals(self.issue.rate_label, 'Medium')
def test_it_rates_the_issue_as_hard(self):
self.issue.rate(4)
self.assertEquals(self.issue.rate_label, 'Hard')
def test_it_rates_the_issue_as_very_hard(self):
self.issue.rate(5)
self.assertEquals(self.issue.rate_label, 'Very Hard')
def test_it_defines_the_current_rate_as_the_rate_avg(self):
self.issue.rate(5)
self.issue.rate(1)
self.assertEquals(self.issue.rate_label, 'Medium')
def test_it_rounds_the_avg(self):
self.issue.rate(5)
self.issue.rate(5)
self.issue.rate(4)
self.assertEquals(self.issue.rate_label, 'Very Hard')
def testIssueAndErrorNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
c = Client()
c.post(reverse("error-post"), test_data)
#assert Notification.all().count() == 2
# this would be 2 when issues are turned on
assert Notification.all().count() == 1
c = Client()
res = c.get(reverse("notification-send"))
self.assertEquals(len(mail.outbox), 1)
def testIssueAndErrorNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
c = Client()
c.post(reverse("error-post"), test_data)
#assert Notification.all().count() == 2
# this would be 2 when issues are turned on
assert Notification.all().count() == 1
c = Client()
res = c.get(reverse("notification-send"))
self.assertEquals(len(mail.outbox), 1)
def test_it_throws_an_exception_given_issue_already_exists(self) -> None:
issue = Issue(
number=1,
name='any title',
body='any body',
main_language=ProgrammingLanguage.get_other_default_language(),
repository=Repository.objects.create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.create(owner='carlosmaniero')))
issue.save()
issues_url = "https://github.com/carlosmaniero/iwannacontrib-issues-test-integration-test/issues/1"
issue_to_be_created = IssueToBeCreated(issues_url)
service = CreateIssueService()
with self.assertRaises(IssueAlreadyExists) as context:
service.create_issue(self.github, issue_to_be_created)
self.assertEquals(context.exception.url, issues_url)
def create_issue(self, github: Github,
issue_to_be_created: IssueToBeCreated) -> Issue:
github_issue = self._get_github_issue(github, issue_to_be_created)
repository = Repository.objects.get_or_create(
name=issue_to_be_created.repository,
owner=Owner.objects.get_or_create(
owner=issue_to_be_created.owner)[0])[0]
if len(repository.issue_set.filter(
number=issue_to_be_created.number)) != 0:
raise IssueAlreadyExists(issue_to_be_created.url)
issue = Issue(number=issue_to_be_created.number,
name=github_issue.title,
body=github_issue.body,
repository=repository,
main_language=self._get_main_language(github_issue))
issue.save()
return issue
def add(self, language_name='Python', **rewrite):
self.issue_number += 1
data = dict(number=self.issue_number,
name=f'any title {self.issue_number}',
body='any body',
main_language=ProgrammingLanguage.objects.get_or_create(
name=language_name)[0],
repository=Repository.objects.get_or_create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.get_or_create(
owner='carlosmaniero')[0])[0])
data.update(**rewrite)
issue = Issue(**data)
issue.save()
return issue
def test_issue_create_filled(self):
year = Year.objects.create(start_year=2016)
group = Group.objects.create(name='name_groups', year=year)
course = Course.objects.create(name='course_name',
year=year)
course.groups = [group]
course.save()
task = Task.objects.create(title='task',
course=course)
student = User.objects.create_user(username='******',
password='******')
responsible = User.objects.create_user(username='******',
password='******')
followers = [User.objects.create_user(username='******',
password='******')]
status = IssueStatus.objects.get(name=u'{"ru": "Зачтено", "en": "Accepted"}')
issue = Issue()
issue.student = student
issue.task = task
issue.mark = 3
issue.responsible = responsible
issue.status_field = status
issue.save()
issue.followers = followers
issue.save()
issue_id = issue.id
issue = Issue.objects.get(id=issue_id)
self.assertIsInstance(issue, Issue)
self.assertEqual(issue.student, student)
self.assertEqual(issue.task, task)
self.assertEqual(issue.mark, 3)
self.assertEqual(issue.responsible, responsible)
self.assertEqual(issue.status_field, status)
self.assertItemsEqual(issue.followers.all(), followers)
def test_vote_proposal(self):
# p = self.test_create_proposal()
######################################
i = Issue(community=self.community,
title="Issue ABC",
created_by=self.chairmen[0])
i.full_clean()
i.save()
title = 'Proposal XYZ'
content = 'hellow world'
p = Proposal.objects.create(type=ProposalType.RULE,
issue=i,
created_by=self.chairmen[0],
title=title,
content=content)
######################################
#TODO: create this via HTML request
pv = ProposalVote(proposal=p,
user=self.members[0],
value=ProposalVoteValue.CON)
pv.full_clean()
pv.save()
return pv
def handle(self,
count,
service,
min_lat=None,
max_lat=None,
min_lon=None,
max_lon=None,
**options):
service = Service.objects.get(service_code=service)
for i in range(count):
lat = long = None
if min_lat and max_lat and min_lon and max_lon:
lat = random.uniform(min_lat, max_lat)
long = random.uniform(min_lon, max_lon)
issue = Issue(
service=service,
lat=lat,
long=long,
submitter_email='*****@*****.**',
description=generate_description(),
)
issue.save()
self.stdout.write('{} issues created'.format(count))
def setUp(self):
u = SandstormUser(sid="xxxdummyxxx", name="Dummy User", handle="dummy")
u.save()
i1 = Issue(title="Foo", description="describe Foo", creator=u, deadline=date.today())
i1.save()
i2 = Issue(title="Bar", description="describe Bar", for_anon=True, creator=u, deadline=date.today() + timedelta(days=2))
i2.save()
i3 = Issue(title="Baz", description="describe Baz", subscriber_only=True, creator=u)
i3.save()
c1_1 = Comment(body="Hohoho", issue=i1, creator=u)
c1_1.save()
c2_1 = Comment(body="Funny!", issue=i1, creator=u)
c2_1.save()
def testIssueNumber(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 1
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 2
old_issue = issue
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 3, issue.number
old_issue.delete()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 4
def testIssueNumber(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 1
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 2
old_issue = issue
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 3, issue.number
old_issue.delete()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 4
def setUp(self):
order = Order(full_name="Name", date="2019-04-08")
order.save()
issue = Issue(title="Test Issue")
issue.save()
class AnyContestTest(TestCase):
@classmethod
def setUpClass(cls):
cls.contest = ContestServerMock()
cls.contest.start()
time.sleep(0.5)
cls.contest_port = cls.contest.httpd.server_address[1]
@classmethod
def tearDownClass(cls):
cls.contest.stop()
def setUp(self):
self.year = Year.objects.create(start_year=2016)
self.group = Group.objects.create(name='name_groups', year=self.year)
self.course = Course.objects.create(name='course_name',
year=self.year)
self.course.groups = [self.group]
self.course.save()
self.task = Task.objects.create(title='task',
course=self.course,
problem_id="A")
self.student = User.objects.create_user(username='******',
password='******')
self.responsible = User.objects.create_user(username='******',
password='******')
status = IssueStatus.objects.get(tag=Issue.STATUS_ACCEPTED)
self.issue = Issue()
self.issue.student = self.student
self.issue.task = self.task
self.issue.responsible = self.responsible
self.issue.status_field = status
self.issue.save()
self.issue.save()
self.issue_id = self.issue.id
def test_contest_info(self):
self.maxDiff = None
# with override_settings(CONTEST_API_URL='http://127.0.0.1:{}/anytask/'.format(self.contest_port))
self.assertDictEqual(get_contest_info(1, lang='ru')[1], tests_data.CONTEST_INFO['result'])
def test_contest_submition_ok(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_rb.py', b'print "hello world!"'), event=event_create_file)
contest_submition.file = f
contest_submition.save()
self.assertTrue(contest_submition.upload_contest("py"))
self.assertEquals(contest_submition.run_id, "1")
def test_contest_submition_fail(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
self.assertFalse(contest_submition.upload_contest("py"))
self.assertEquals(contest_submition.send_error, "Submit error in fake server!")
def test_check_submission_ok(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "1"
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertIn(u'<p>{0}: ok</p>'.format(_(u'verdikt_jakontest')), comment)
self.assertTrue(contest_submition.got_verdict)
def test_check_submission_precompile_check_failed(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "2"
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertIn(u'<p>{0}: precompile-check-failed</p>'.format(_(u'verdikt_jakontest')), comment)
self.assertTrue(contest_submition.got_verdict)
self.assertIn('precompile-check-failed-1', comment)
self.assertIn('precompile-check-failed-2', comment)
self.assertIn('precompile-check-failed-3', comment)
def test_check_submission_failed(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "3"
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertTrue(contest_submition.got_verdict)
self.assertIn(u'<p>{0}: failed</p>'.format(_(u'verdikt_jakontest')), comment)
self.assertIn("1ms/1.91Mb", comment)
self.assertIn("input", comment)
self.assertIn("output", comment)
self.assertIn("answer", comment)
self.assertIn("error", comment)
self.assertIn("message", comment)
@skip("Bad error handling on this case")
def test_check_submission_bad_answer(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "4"
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
contest_submition.check_submission() # Contest returns 501 here and no JSON
self.assertFalse(contest_submition.got_verdict)
def test_check_submission_wrong_json(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "5"
event_create_file = Event.objects.create(issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile('test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
contest_submition.check_submission()
self.assertFalse(contest_submition.got_verdict)
class ErrorTests(TestCase):
# test the view for writing errors
def setUp(self):
for issue in Issue.all():
issue.delete()
for log in Log.all():
log.delete()
for comment in Comment.all():
comment.delete()
for group in Group.all():
group.delete()
for error in Error.all():
error.delete()
for project in Project.all():
project.delete()
def testLogAdded(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.log_set[0]
def testIssueNumber(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 1
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 2
old_issue = issue
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 3, issue.number
old_issue.delete()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 4
def _setup(self):
self.project = Project(name="testing")
self.project.save()
self.url = ProjectURL(url="http://test.areciboapp.com")
self.url.project = self.project
self.url.save()
self.url = ProjectURL(url="http://www.areciboapp.com")
self.url.project = self.project
self.url.save()
self.error = Error()
for k, v in break_url("http://test.areciboapp.com/an/other").items():
setattr(self.error, k, v)
self.error.save()
def _issue(self):
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.save()
def testIssueGroup(self):
self._setup()
self._issue()
group = Group.all()[0]
self.issue.add_group(group)
assert group == self.issue.issuegroup_set[0].group
assert self.issue.issuegroup_set.count() == 1
assert self.issue == IssueGroup.all().filter("issue = ",
self.issue)[0].issue
def testIssueURL(self):
self._setup()
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.project = self.project
self.issue.save()
assert self.issue.issueprojecturl_set.count() == 2
assert self.issue.issueprojecturl_set[0].status == "not_fixed"
def testIssueURLFlexibility(self):
self._setup()
self._issue()
assert self.issue == issue_by_number(self.issue.number)
assert self.issue == issue_by_number(self.issue.number)
def testIssueChanged(self):
self.signal_fired = False
def signal_fired(instance, old, **kw):
self.signal_fired = True
signals.issue_changed.connect(signal_fired,
dispatch_uid="issue_changed")
self._issue()
self.issue.status = "rejected"
self.issue.save()
assert self.signal_fired
def testIssuePriorityChanged(self):
self.signal_fired = False
def signal_fired(instance, old, new, **kw):
self.signal_fired = True
assert old in (None, 1)
assert new in (1, 2)
signals.issue_priority_changed.connect(
signal_fired, dispatch_uid="issue_priority_changed")
self._issue()
self.issue.priority = 1
self.issue.save()
assert self.signal_fired
self.signal_fired = False
self.issue.priority = 2
self.issue.save()
assert self.signal_fired
def testIssueStatusChanged(self):
self.signal_fired = False
def signal_fired(instance, old, new, **kw):
self.signal_fired = True
assert not old
assert new == "rejected"
signals.issue_status_changed.connect(
signal_fired, dispatch_uid="issue_status_changed")
self._issue()
self.issue.status = "rejected"
self.issue.save()
assert self.signal_fired
self.signal_fired = False
self.issue.priority = 1
self.issue.save()
assert not self.signal_fired
def testLogAdded(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.log_set[0]
def testLogAdded(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.log_set[0]
usr = Author()
usr_dict[user_id] = usr
if (obj['meta_key'] == 'first_name'):
usr.first_name = obj['meta_value']
print usr
if (obj['meta_key'] == 'last_name'):
usr.last_name = obj['meta_value']
for k, v in usr_dict.items():
v.save()
oldissue = Issue(volume = 109, issue = 1)
oldissue.save()
post_data=open('posteroo.json')
data = json.load(post_data)
post_dict = {}
for obj in data:
if (obj['post_status'] != "publish"):
continue;
if (len(obj['post_content']) == 0) :
continue;
if (len(obj['post_title']) == 0) :
class AnyContestTest(TestCase):
@classmethod
def setUpClass(cls):
cls.contest = ContestServerMock()
cls.contest.start()
time.sleep(0.5)
cls.contest_port = cls.contest.httpd.server_address[1]
@classmethod
def tearDownClass(cls):
cls.contest.stop()
def setUp(self):
self.year = Year.objects.create(start_year=2016)
self.group = Group.objects.create(name='name_groups', year=self.year)
self.course = Course.objects.create(name='course_name', year=self.year)
self.course.groups = [self.group]
self.course.save()
self.task = Task.objects.create(title='task',
course=self.course,
problem_id="A")
self.student = User.objects.create_user(username='******',
password='******')
self.responsible = User.objects.create_user(username='******',
password='******')
status = IssueStatus.objects.get(tag=Issue.STATUS_ACCEPTED)
self.issue = Issue()
self.issue.student = self.student
self.issue.task = self.task
self.issue.responsible = self.responsible
self.issue.status_field = status
self.issue.save()
self.issue.save()
self.issue_id = self.issue.id
def test_contest_info(self):
self.maxDiff = None
# with override_settings(CONTEST_API_URL='http://127.0.0.1:{}/anytask/'.format(self.contest_port))
self.assertDictEqual(
get_contest_info(1, lang='ru')[1],
tests_data.CONTEST_INFO['result'])
def test_contest_submition_ok(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_rb.py', b'print "hello world!"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
self.assertTrue(contest_submition.upload_contest("py"))
self.assertEquals(contest_submition.run_id, "1")
def test_contest_submition_fail(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
self.assertFalse(contest_submition.upload_contest("py"))
self.assertEquals(contest_submition.send_error,
"Submit error in fake server!")
def test_check_submission_ok(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "1"
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertIn(u'<p>{0}: ok</p>'.format(_(u'verdikt_jakontest')),
comment)
self.assertTrue(contest_submition.got_verdict)
def test_check_submission_precompile_check_failed(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "2"
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertIn(
u'<p>{0}: precompile-check-failed</p>'.format(
_(u'verdikt_jakontest')), comment)
self.assertTrue(contest_submition.got_verdict)
self.assertIn('precompile-check-failed-1', comment)
self.assertIn('precompile-check-failed-2', comment)
self.assertIn('precompile-check-failed-3', comment)
def test_check_submission_failed(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "3"
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
comment = contest_submition.check_submission()
self.assertTrue(contest_submition.got_verdict)
self.assertIn(u'<p>{0}: failed</p>'.format(_(u'verdikt_jakontest')),
comment)
self.assertIn("1ms/1.91Mb", comment)
self.assertIn("input", comment)
self.assertIn("output", comment)
self.assertIn("answer", comment)
self.assertIn("error", comment)
self.assertIn("message", comment)
@skip("Bad error handling on this case")
def test_check_submission_bad_answer(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "4"
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
contest_submition.check_submission(
) # Contest returns 501 here and no JSON
self.assertFalse(contest_submition.got_verdict)
def test_check_submission_wrong_json(self):
contest_submition = ContestSubmission()
contest_submition.issue = self.issue
contest_submition.author = self.student
contest_submition.run_id = "5"
event_create_file = Event.objects.create(
issue=self.issue, field=IssueField.objects.get(name='file'))
f = File.objects.create(file=SimpleUploadedFile(
'test_fail_rb.py', b'print "_failed_"'),
event=event_create_file)
contest_submition.file = f
contest_submition.save()
contest_submition.check_submission()
self.assertFalse(contest_submition.got_verdict)
def checkout(request):
if request.method == 'POST':
order_form = OrderForm(request.POST)
payment_form = MakePaymentForm(request.POST)
if order_form.is_valid() and payment_form.is_valid():
cart_items = Cart.objects.filter(user=request.user)
payment_total = 0
for item in cart_items:
payment_total += item.amount
try:
customer = stripe.Charge.create(
amount = int(payment_total * 100),
currency = 'EUR',
description = request.user.email,
card = payment_form.cleaned_data['stripe_id']
)
except stripe.error.CardError:
messages.error(request, 'Your card was declined.')
if customer.paid:
messages.success(request, 'You have successfully paid.')
order_instance = order_form.save(commit=False)
order_instance.date = timezone.now()
order_instance.user = request.user
order_instance.save()
for item in cart_items:
if item.request_type == 'new feature':
new_feature = Issue(
issue_type = 'feature',
title = item.title,
description = item.description,
date_created = timezone.now(),
author = request.user,
total_paid = item.amount
)
new_feature.save()
order_line_item = OrderLineItem(
order = order_instance,
issue = new_feature,
request_type = item.request_type,
amount_paid = item.amount
)
order_line_item.save()
elif item.request_type == 'feature vote':
this_feature = Issue.objects.get(pk=item.feature_id)
current_amount = this_feature.total_paid
new_amount = current_amount + item.amount
Issue.objects.filter(pk=item.feature_id).update(total_paid=new_amount)
new_vote = IssueVote()
current_user = User.objects.get(username=request.user)
new_vote.issue = this_feature
new_vote.user = current_user
new_vote.save()
order_line_item = OrderLineItem(
order = order_instance,
issue = this_feature,
request_type = item.request_type,
amount_paid = item.amount
)
order_line_item.save()
Cart.objects.filter(user=request.user).delete()
return redirect(reverse('tracker'))
else:
message.error(request, 'Unable to take payment.')
else:
messages.error(request, 'We were unable to take a payment with that card.')
cart = Cart.objects.all().filter(user=request.user)
cart = Cart.objects.filter(user=request.user)
cart_count = Cart.objects.filter(user=request.user).count()
cart_total = 0
for item in cart:
cart_total += item.amount
else:
payment_form = MakePaymentForm()
order_form = OrderForm()
cart = Cart.objects.filter(user=request.user)
cart_count = Cart.objects.filter(user=request.user).count()
cart_total = 0
for item in cart:
cart_total += item.amount
return render(request, 'checkout.html', {
'payment_form': payment_form,
'order_form': order_form,
'publishable': settings.STRIPE_PUBLISHABLE,
'cart': cart,
'cart_total': cart_total,
'cart_count': cart_count
})
def _submit_review(self, request, task, svn_path):
user = request.user
try:
rev_a = int(request.POST.get('rev_a'))
rev_b = int(request.POST.get('rev_b'))
except TypeError: #not int
return HttpResponseForbidden()
except ValueError: #not int
return HttpResponseForbidden()
if rev_a == rev_b:
return HttpResponseForbidden()
if rev_b < rev_a:
rev_a, rev_b = rev_b, rev_a
review_id = None
try:
issue = Issue.objects.filter(task=task, student=user).order_by('-update_time')[0]
review_id = issue.rb_review_id
except Issue.DoesNotExist:
pass
except IndexError:
pass
issue = Issue()
issue.task = task
issue.student = user
issue.svn_commit_id = rev_b
summary = u"[{0}][{1}] {2}".format(user.get_full_name(), task.course.get_user_group(user), task.title)
review_group_name = settings.RB_API_DEFAULT_REVIEW_GROUP
if task.course.name_id:
review_group_name = "teachers_{0}".format(task.course.name_id)
else:
try:
review_group_name = "teachers_{0}".format(task.course.name)
except Exception:
pass
review_group_name = review_group_name.replace(".", "_")
review_group_name = review_group_name.replace("/", "_")
review_group_name = review_group_name.lower()
anyrb = AnyRB()
description = self._get_description(request, task, svn_path, rev_a, rev_b)
if review_id is None:
review_id = anyrb.submit_review(user, rev_a, rev_b, summary=summary, description=description, review_group_name=", ".join((review_group_name, settings.RB_API_DEFAULT_REVIEW_GROUP)), path=svn_path)
else:
anyrb.update_review(user, rev_a, rev_b, review_id, description=description, path=svn_path)
issue.rb_review_id = review_id
issue.save()
context = {
'review_url' : anyrb.get_review_url(request, review_id),
'task' : task,
}
return render_to_response('submit_review_done.html', context, context_instance=RequestContext(request))
def test_add_to_cart(self):
issue = Issue(title="Test Issue")
issue.save()
page = self.client.get("/cart/add/{0}".format(issue.id))
self.assertEqual(page.status_code, 302)
class TestViews(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpassword')
self.client.login(username='******', password='******')
self.open_bug = Issue(issue_type='bug',
title='testbug1',
description='testdescription1',
author=self.user)
self.open_bug.save()
self.open_feature = Issue(issue_type='feature',
title='testfeature1',
description='testdescription1',
author=self.user)
self.open_feature.save()
self.closed_bug = Issue(issue_type='bug',
title='testbug2',
description='testdescription2',
author=self.user,
status='closed')
self.closed_bug.save()
self.closed_bug.date_complete = timezone.now()
self.closed_bug.save()
self.closed_feature = Issue(issue_type='feature',
title='testfeature2',
description='testdescription2',
author=self.user,
status='closed')
self.closed_feature.save()
self.closed_feature.date_complete = timezone.now()
self.closed_feature.save()
def test_get_stats_page(self):
cart_item = Cart(title='new suggested feature',
description='will make the app better',
user=self.user,
request_type='new feature',
amount=50)
cart_item.save()
response = self.client.get(reverse(stats))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'stats.html')
def test_top_bugs(self):
response = self.client.get(reverse(top_bugs))
self.assertEqual(response.status_code, 200)
def test_top_features(self):
response = self.client.get(reverse(top_features))
self.assertEqual(response.status_code, 200)
def test_bug_closure(self):
response = self.client.get(reverse(bug_closure))
self.assertEqual(response.status_code, 200)
def test_feature_closure(self):
response = self.client.get(reverse(feature_closure))
self.assertEqual(response.status_code, 200)
from sys import argv import django django.setup() saveToDatabase=argv[1] from django.utils import timezone from issues.models import Issue, Assignee issue = Issue(issue_label="test issue", pub_date=timezone.now()) if saveToDatabase == "save": issue.save() print "Issue id: %i" % issue.id print issue assignee = Assignee(name="John Hakala", email="*****@*****.**") if saveToDatabase == "save": assignee.save() print "Assignee id: %i" % assignee.id print assignee
class ErrorTests(TestCase):
# test the view for writing errors
def setUp(self):
for issue in Issue.all(): issue.delete()
for log in Log.all(): log.delete()
for comment in Comment.all(): comment.delete()
for group in Group.all(): group.delete()
for error in Error.all(): error.delete()
for project in Project.all(): project.delete()
def testLogAdded(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.log_set[0]
def _setup(self):
self.project = Project(name="testing")
self.project.save()
self.url = ProjectURL(url="http://test.areciboapp.com")
self.url.project = self.project
self.url.save()
self.url = ProjectURL(url="http://www.areciboapp.com")
self.url.project = self.project
self.url.save()
self.error = Error()
for k, v in break_url("http://test.areciboapp.com/an/other").items():
setattr(self.error, k, v)
self.error.save()
def _issue(self):
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.save()
def testIssueGroup(self):
self._setup()
self._issue()
group = Group.all()[0]
self.issue.add_group(group)
assert group == self.issue.issuegroup_set[0].group
assert self.issue.issuegroup_set.count() == 1
assert self.issue == IssueGroup.all().filter("issue = ", self.issue)[0].issue
def testIssueURL(self):
self._setup()
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.project = self.project
self.issue.save()
assert self.issue.issueprojecturl_set.count() == 2
assert self.issue.issueprojecturl_set[0].status == "not_fixed"
def testIssueURLFlexibility(self):
self._setup()
self._issue()
assert self.issue == issue_by_number(self.issue.number)
assert self.issue == issue_by_number(self.issue.number)
def testIssueChanged(self):
self.signal_fired = False
def signal_fired(instance, old, **kw):
self.signal_fired = True
signals.issue_changed.connect(signal_fired, dispatch_uid="issue_changed")
self._issue()
self.issue.status = "rejected"
self.issue.save()
assert self.signal_fired
def testIssuePriorityChanged(self):
self.signal_fired = False
def signal_fired(instance, old, new, **kw):
self.signal_fired = True
assert old in (None, 1)
assert new in (1, 2)
signals.issue_priority_changed.connect(signal_fired, dispatch_uid="issue_priority_changed")
self._issue()
self.issue.priority = 1
self.issue.save()
assert self.signal_fired
self.signal_fired = False
self.issue.priority = 2
self.issue.save()
assert self.signal_fired
def testIssueStatusChanged(self):
self.signal_fired = False
def signal_fired(instance, old, new, **kw):
self.signal_fired = True
assert not old
assert new == "rejected"
signals.issue_status_changed.connect(signal_fired, dispatch_uid="issue_status_changed")
self._issue()
self.issue.status = "rejected"
self.issue.save()
assert self.signal_fired
self.signal_fired = False
self.issue.priority = 1
self.issue.save()
assert not self.signal_fired
def create(request):
errors = []
if 'submit' in request.POST:
issue = Issue()
issue.title = request.POST['title']
issue.content = request.POST['content']
issue.creator = request.user
due_time = request.POST.get('due_time', '').strip()
if len(due_time):
try:
due_time = parse_date(due_time)
if due_time:
issue.due_time = due_time
else:
errors.append('date-misformed')
except ValueError:
errors.append('date-invalid')
assignee = request.POST.get('assignee')
if assignee: # Empty value => not assigned, no need to set
try:
issue.assignee = User.objects.get(id=assignee)
except User.DoesNotExist:
assignee = None # Just in case we're under attack...
labels = []
for label_id in request.POST.getlist('labels'):
try:
labels.append(Label.objects.get(id=label_id))
except Label.DoesNotExist:
pass
if not errors:
issue.save(
) # Need to save before we can enforce N to N relationship
issue.starring.add(request.user) # Auto watch
# Add or remove labels has history so we don't worry on history creation
issue.labels.add(*labels)
mentions, _ = filter_mentions(issue.content)
if assignee:
mentions.add(issue.assignee)
mentions.discard(request.user)
for user in mentions:
issue.starring.add(user) # Auto watch
send_mail(request.user, user, 'mail/issue_created.html',
{'issue': issue})
# Broadcast new issues automatically
send_mail(request.user, settings.BROADCAST_EMAIL,
'mail/issue_created.html', {'issue': issue})
if assignee:
IssueHistory.objects.create(issue=issue,
user=request.user,
mode=IssueHistory.ASSIGN,
content=assignee)
if due_time:
IssueHistory.objects.create(issue=issue,
user=request.user,
mode=IssueHistory.SET_DUE,
content=due_time)
return redirect('issues:detail', issue.id)
return render(
request, 'issues/create.html', {
'labels': Label.objects.all(),
'users': sorted_users(User.objects.filter(is_active=True)),
'errors': errors,
})
def create(request):
errors = []
if 'submit' in request.POST:
issue = Issue()
issue.title = request.POST['title']
issue.content = request.POST['content']
issue.creator = request.user
due_time = request.POST.get('due_time', '').strip()
if len(due_time):
try:
due_time = parse_date(due_time)
if due_time:
issue.due_time = due_time
else:
errors.append('date-misformed')
except ValueError:
errors.append('date-invalid')
assignee = request.POST.get('assignee')
if assignee: # Empty value => not assigned, no need to set
try:
issue.assignee = User.objects.get(id=assignee)
except User.DoesNotExist:
assignee = None # Just in case we're under attack...
labels = []
for label_id in request.POST.getlist('labels'):
try:
labels.append(Label.objects.get(id=label_id))
except Label.DoesNotExist: pass
if not errors:
issue.save() # Need to save before we can enforce N to N relationship
issue.starring.add(request.user) # Auto watch
# Add or remove labels has history so we don't worry on history creation
issue.labels.add(*labels)
mentions, _ = filter_mentions(issue.content)
if assignee:
mentions.add(issue.assignee)
mentions.discard(request.user)
for user in mentions:
issue.starring.add(user) # Auto watch
send_mail(request.user, user, 'mail/issue_created.html', { 'issue': issue })
# Broadcast new issues automatically
send_mail(request.user, settings.BROADCAST_EMAIL, 'mail/issue_created.html', { 'issue': issue })
if assignee:
IssueHistory.objects.create(issue=issue, user=request.user,
mode=IssueHistory.ASSIGN, content=assignee)
if due_time:
IssueHistory.objects.create(issue=issue, user=request.user,
mode=IssueHistory.SET_DUE, content=due_time)
return redirect('issues:detail', issue.id)
return render(request, 'issues/create.html', {
'labels': Label.objects.all(),
'users': sorted_users(User.objects.filter(is_active=True)),
'errors': errors,
})
