def test_get_jobs_deleted_target(self):
user = self.guest_login()
entity = Entity.objects.create(name='entity', created_user=user)
entry = Entry.objects.create(name='entry', created_user=user, schema=entity)
Job.new_create(user, entry)
resp = self.client.get('/job/')
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.context['jobs']), 1)
# check the case show jobs after deleting job target
entry.delete()
# Create delete job
Job.new_delete(user, entry)
resp = self.client.get('/job/')
self.assertEqual(resp.status_code, 200)
# Confirm that the delete job can be obtained
self.assertEqual(len(resp.context['jobs']), 1)
self.assertEqual(resp.context['jobs'][0]['operation'], JobOperation.DELETE_ENTRY.value)
# check respond HTML has expected elements which are specified of CSS selectors
parser = HTML(html=resp.content.decode('utf-8'))
job_elems = parser.find('#entry_container .job_info')
self.assertEqual(len(job_elems), 1)
for job_elem in job_elems:
for _cls in ['target', 'status', 'execution_time', 'created_at', 'note', 'operation']:
self.assertIsNotNone(job_elem.find('.%s' % _cls))
def wm_import_job(self):
for job in Job.objects.all():
job.delete()
wm_jobs = WorkflowmaxJob.objects.all(datetime.now() - timedelta(days=365), datetime.now() + timedelta(days=365))
for wm_job in wm_jobs:
job = Job()
job.wm_import(wm_job)
def test_increase_max_tries_failed(self):
'''Tests increasing the maximum number of tries for a job instance that ran out of tries due to failures.'''
job_type = JobType(max_tries=10)
job = Job(job_type=job_type, num_exes=5, max_tries=5)
job.increase_max_tries()
self.assertEqual(job.max_tries, 15)
def export_search_result(request, recv_data):
# additional validation
if recv_data['export_style'] != 'yaml' and recv_data[
'export_style'] != 'csv':
return HttpResponse('Invalid "export_type" is specified', status=400)
user = User.objects.get(id=request.user.id)
# check whether same job is sent
job_status_not_finished = [
Job.STATUS['PREPARING'], Job.STATUS['PROCESSING']
]
if Job.get_job_with_params(
user,
recv_data).filter(status__in=job_status_not_finished).exists():
return HttpResponse('Same export processing is under execution',
status=400)
# create a job to export search result and run it
job = Job.new_export_search_result(
user, **{
'text': 'search_results.%s' % recv_data['export_style'],
'params': recv_data,
})
job.run()
return JsonResponse({
'result':
'Succeed in registering export processing. ' + 'Please check Job list.'
})
def test_when_title_is_more_than_max_length_should_raise_error(self):
job = Job(
title=
'Lorem Ipsum is simply dummy text of the printing and typesetting industry. '
'Lorem Ipsum has been the industrys standard dummy text ever since the 1500s, '
'when an unknown printer took a galley of type and scrambled it to make a type '
'specimen book. It has survived not only five centuries, but also the leap into '
'electronic typesetting, remaining essentially unchanged. It was popularised in '
'the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, '
'and more recently with desktop publishing software like Aldus PageMaker '
'including versions of Lorem Ipsum.',
experience=1,
salary_min=5000.00,
salary_max=10000.00,
qualification=self.qualification,
job_gender=self.job_gender,
application_deadline='',
description='Test job',
responsibilities='Web developer',
education='Computer Science',
other_benefits='Apple Watch',
company=self.company,
latitude=3.00,
longitude=4.00,
)
with self.assertRaises(ValidationError):
job.full_clean(exclude=exclude)
def test_get_object(self):
Entry.objects.create(name='entry',
created_user=self.guest,
schema=self.entity)
params = {
'entities': self.entity.id,
'attrinfo': {
'name': 'foo',
'keyword': ''
},
'export_style': '"yaml"',
}
# check there is no job
self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
# create a new job
job = Job.new_export(self.guest, text='hoge', params=params)
self.assertEqual(job.target_type, Job.TARGET_UNKNOWN)
self.assertEqual(job.operation, Job.OP_EXPORT)
self.assertEqual(job.text, 'hoge')
# check created job is got by specified params
self.assertEqual(
Job.get_job_with_params(self.guest, params).count(), 1)
self.assertEqual(
Job.get_job_with_params(self.guest, params).last(), job)
# check the case when different params is specified then it returns None
params['attrinfo']['name'] = ''
self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
def test_job_download_failure(self):
user = self.guest_login()
entity = Entity.objects.create(name="entity", created_user=user)
job = Job.new_create(user, entity, "hoge")
# When user send a download request of Job with invalid Job-id, then HTTP 400 is returned
resp = self.client.get("/job/download/%d" % (job.id + 1))
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content.decode(), "Invalid Job-ID is specified")
# When user send a download request of non export Job, then HTTP 400 is returned
resp = self.client.get("/job/download/%d" % job.id)
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content.decode(),
"Target Job has no value to return")
# The case user sends a download request for a job which doesn't have a result
job = Job.new_export(user, text="fuga")
resp = self.client.get("/job/download/%d" % job.id)
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content.decode(),
"This result is no longer available")
# When user send a download request of export Job by differenct user from creating one,
# then HTTP 400 is returned
job = Job.new_export(user, text="fuga")
user = self.admin_login()
resp = self.client.get("/job/download/%d" % job.id)
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content.decode(),
"Target Job is executed by other people")
def test_increment_slots_remaining(self):
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j1.save()
s1 = Shift(date = "2012-10-23",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 0,
job = j1)
s1.save()
self.assertEqual(s1.slots_remaining, 0)
increment_slots_remaining(s1)
self.assertEqual(s1.slots_remaining, 1)
increment_slots_remaining(s1)
self.assertEqual(s1.slots_remaining, 2)
increment_slots_remaining(s1)
self.assertEqual(s1.slots_remaining, 3)
increment_slots_remaining(s1)
self.assertEqual(s1.slots_remaining, 4)
def test_get_jobs_deleted_target(self):
user = self.guest_login()
entity = Entity.objects.create(name='entity', created_user=user)
entry = Entry.objects.create(name='entry',
created_user=user,
schema=entity)
Job.new_create(user, entry)
resp = self.client.get('/job/')
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.context['jobs']), 1)
# check the case show jobs after deleting job target
entry.delete()
# Create delete job
Job.new_delete(user, entry)
resp = self.client.get('/job/')
self.assertEqual(resp.status_code, 200)
# Confirm that the delete job can be obtained
self.assertEqual(len(resp.context['jobs']), 1)
self.assertEqual(resp.context['jobs'][0]['operation'],
JobOperation.DELETE_ENTRY.value)
def create(request, project_id):
project = get_object_or_404(
Project,
id=project_id,
is_active=True,
author=request.user
)
if request.method == 'POST':
form = JobForm(request.POST)
if form.is_valid():
job = Job(
project=project,
title=form.cleaned_data['title'],
area=form.cleaned_data['area'],
description=form.cleaned_data['description']
)
job.save()
return redirect(
request,
'project-read',
[project.id],
{request.url_name: 'True'}
)
else:
form = JobForm()
params = {'project': project, 'form': form}
params.update(csrf(request))
return response(request, params)
def test_get_object(self):
params = {
"entities": self.entity.id,
"attrinfo": {
"name": "foo",
"keyword": ""
},
"export_style": '"yaml"',
}
# check there is no job
self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
# create a new job
job = Job.new_export(self.guest, text="hoge", params=params)
self.assertEqual(job.target_type, Job.TARGET_UNKNOWN)
self.assertEqual(job.operation, JobOperation.EXPORT_ENTRY.value)
self.assertEqual(job.text, "hoge")
# check created job is got by specified params
self.assertEqual(
Job.get_job_with_params(self.guest, params).count(), 1)
self.assertEqual(
Job.get_job_with_params(self.guest, params).last(), job)
# check the case when different params is specified then it returns None
params["attrinfo"]["name"] = ""
self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
def test_increase_max_tries_canceled(self):
'''Tests increasing the maximum number of tries for a job instance that was canceled prematurely.'''
job_type = JobType(max_tries=10)
job = Job(job_type=job_type, num_exes=3, max_tries=5)
job.increase_max_tries()
self.assertEqual(job.max_tries, 13)
def test_get_shift_slots_remaining(self):
""" Test get_shift_slots_remaining(s_id) """
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j1.save()
s1 = Shift(date="2012-12-10", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)
s2 = Shift(date="2012-6-25", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)
s3 = Shift(date="2012-1-9", start_time="12:00", end_time="6:00", max_volunteers=4, job=j1)
s1.save()
s2.save()
s3.save()
self.assertIsNotNone(get_shift_slots_remaining(s1.id))
self.assertIsNotNone(get_shift_slots_remaining(s2.id))
self.assertIsNotNone(get_shift_slots_remaining(s3.id))
def test_get_non_target_job(self):
user = self.guest_login()
Job.new_create(user, None)
resp = self.client.get("/job/")
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.context["jobs"]), 0)
def test_get_non_target_job(self):
user = self.guest_login()
Job.new_create(user, None)
resp = self.client.get('/job/api/v2/jobs')
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.json()), 0)
def test_get_exporting_job(self):
user = self.guest_login()
# create jobs which are related with export
Job.new_export(user),
Job.new_export_search_result(user),
resp = self.client.get('/job/api/v2/jobs')
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.json()), 2)
def test_get_exporting_job(self):
user = self.guest_login()
# create jobs which are related with export
Job.new_export(user),
Job.new_export_search_result(user),
resp = self.client.get("/job/")
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.context["jobs"]), 2)
def postjob(request):
if request.method == 'POST':
obj2 = Job(jtitle=request.POST['jtitle'],
jcname=request.POST['jcompany'],
jobtype=request.POST['job-type'],
jstate=request.POST['jstate'],
jdistrict=request.POST['jdistrict'],
jdesc=request.POST['jdesc'])
obj2.save()
return render(request, 'adminpanel/postjob.html')
def test_get_jobs_ordered_by_title(self):
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j2 = Job(job_title = "Systems Administrator",
start_date = "2012-9-1",
end_date = "2012-10-26",
description = "A systems administrator job")
j3 = Job(job_title = "Project Manager",
start_date = "2012-1-2",
end_date = "2012-2-2",
description = "A management job")
j1.save()
j2.save()
j3.save()
#test typical case
job_list = get_jobs_ordered_by_title()
self.assertIsNotNone(job_list)
self.assertNotEqual(job_list, False)
self.assertEqual(len(job_list), 3)
self.assertIn(j1, job_list)
self.assertIn(j2, job_list)
self.assertIn(j3, job_list)
#test order
self.assertEqual(job_list[0].job_title, j3.job_title)
self.assertEqual(job_list[1].job_title, j1.job_title)
self.assertEqual(job_list[2].job_title, j2.job_title)
def do_edit(request, entry_id, recv_data):
entry, error = get_obj_with_check_perm(request.user, Entry, entry_id,
ACLType.Writable)
if error:
return error
# checks that a same name entry corresponding to the entity is existed.
query = Q(schema=entry.schema,
name=recv_data["entry_name"]) & ~Q(id=entry.id)
if Entry.objects.filter(query).exists():
return HttpResponse("Duplicate name entry is existed", status=400)
# validate contexts of each attributes
err = _validate_input(recv_data, entry)
if err:
return err
if entry.get_status(Entry.STATUS_CREATING):
return HttpResponse("Target entry is now under processing", status=400)
if custom_view.is_custom("do_edit_entry", entry.schema.name):
# resp is HttpReponse instance or its subclass (e.g. JsonResponse)
resp = custom_view.call_custom("do_edit_entry", entry.schema.name,
request, recv_data, request.user, entry)
if resp:
return resp
# update name of Entry object. If name would be updated, the elasticsearch data of entries that
# refers this entry also be updated by creating REGISTERED_REFERRALS task.
job_register_referrals = None
if entry.name != recv_data["entry_name"]:
job_register_referrals = Job.new_register_referrals(
request.user, entry)
entry.name = recv_data["entry_name"]
entry.save(update_fields=["name"])
# set flags that indicates target entry is under processing
entry.set_status(Entry.STATUS_EDITING)
# Create new jobs to edit entry and notify it to registered webhook endpoint if it's necessary
job_edit_entry = Job.new_edit(request.user, entry, params=recv_data)
job_edit_entry.run()
# running job of re-register referrals because of chaning entry's name
if job_register_referrals:
job_register_referrals.dependent_job = job_edit_entry
job_register_referrals.run()
return JsonResponse({
"entry_id": entry.id,
"entry_name": entry.name,
})
def create_job_with_details(job):
"""
Creates and returns job with passed name and dates
"""
j1 = Job(name=job[0],
start_date=job[1],
end_date=job[2],
description=job[3],
event=job[4])
j1.save()
return j1
def create_job_with_details(job):
"""
Creates and returns job with passed name and dates
"""
j1 = Job(name=job['name'],
start_date=job['start_date'],
end_date=job['end_date'],
description=job['description'],
event=job['event'])
j1.save()
return j1
def get_shifts_ordered_by_date(self):
e1 = Event(name = "Open Source Event",
start_date = "2012-10-22",
end_date = "2012-10-23")
e1.save()
j1 = Job(name = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job",
event = e1)
j1.save()
s1 = Shift(date = "2012-1-10",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
job = j1)
s2 = Shift(date = "2012-6-25",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
job = j1)
s3 = Shift(date = "2012-12-9",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
job = j1)
s1.save()
s2.save()
s3.save()
#test typical case
shift_list = get_shifts_ordered_by_date(j1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 3)
self.assertIn(s1, shift_list)
self.assertIn(s2, shift_list)
self.assertIn(s3, shift_list)
#test order
self.assertEqual(shift_list[0].date, s1.date)
self.assertEqual(shift_list[1].date, s2.date)
self.assertEqual(shift_list[2].date, s3.date)
def get_shifts_ordered_by_date(self):
e1 = Event(name="Open Source Event",
start_date="2012-10-22",
end_date="2012-10-23")
e1.save()
j1 = Job(name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1)
j1.save()
s1 = Shift(date="2012-1-10",
start_time="9:00",
end_time="3:00",
max_volunteers=1,
job=j1)
s2 = Shift(date="2012-6-25",
start_time="10:00",
end_time="4:00",
max_volunteers=2,
job=j1)
s3 = Shift(date="2012-12-9",
start_time="12:00",
end_time="6:00",
max_volunteers=4,
job=j1)
s1.save()
s2.save()
s3.save()
#test typical case
shift_list = get_shifts_ordered_by_date(j1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 3)
self.assertIn(s1, shift_list)
self.assertIn(s2, shift_list)
self.assertIn(s3, shift_list)
#test order
self.assertEqual(shift_list[0].date, s1.date)
self.assertEqual(shift_list[1].date, s2.date)
self.assertEqual(shift_list[2].date, s3.date)
def test_get_shift_by_id(self):
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j1.save()
s1 = Shift(date="2012-10-23", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)
s2 = Shift(date="2012-10-23", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)
s3 = Shift(date="2012-10-23", start_time="12:00", end_time="6:00", max_volunteers=4, job=j1)
s1.save()
s2.save()
s3.save()
# test typical cases
self.assertIsNotNone(get_shift_by_id(s1.id))
self.assertIsNotNone(get_shift_by_id(s2.id))
self.assertIsNotNone(get_shift_by_id(s3.id))
self.assertEqual(get_shift_by_id(s1.id), s1)
self.assertEqual(get_shift_by_id(s2.id), s2)
self.assertEqual(get_shift_by_id(s3.id), s3)
# test non-existant cases
self.assertIsNone(get_shift_by_id(100))
self.assertIsNone(get_shift_by_id(200))
self.assertIsNone(get_shift_by_id(300))
self.assertIsNone(get_shift_by_id(400))
self.assertNotEqual(get_shift_by_id(100), s1)
self.assertNotEqual(get_shift_by_id(100), s2)
self.assertNotEqual(get_shift_by_id(100), s3)
self.assertNotEqual(get_shift_by_id(200), s1)
self.assertNotEqual(get_shift_by_id(200), s2)
self.assertNotEqual(get_shift_by_id(200), s3)
self.assertNotEqual(get_shift_by_id(300), s1)
self.assertNotEqual(get_shift_by_id(300), s2)
self.assertNotEqual(get_shift_by_id(300), s3)
def create_job_with_details(job):
"""
Creates and returns job with passed name and dates
"""
j1 = Job(
name=job[0],
start_date=job[1],
end_date=job[2],
description=job[3],
event=job[4])
j1.save()
return j1
def get_shifts_by_date(self):
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j1.save()
s1 = Shift(date = "2012-1-10",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 1,
job = j1)
s2 = Shift(date = "2012-6-25",
location = "Infinite Loop",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
slots_remaining = 2,
job = j1)
s3 = Shift(date = "2012-12-9",
location = "Loopy Loop Road",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
slots_remaining = 4,
job = j1)
s1.save()
s2.save()
s3.save()
#test typical case
shift_list = get_shifts_by_date(j1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 3)
self.assertIn(s1, shift_list)
self.assertIn(s2, shift_list)
self.assertIn(s3, shift_list)
#test order
self.assertEqual(shift_list[0].date, s1.date)
self.assertEqual(shift_list[1].date, s2.date)
self.assertEqual(shift_list[2].date, s3.date)
def test__when_slug_name_duplicate__should_raise_error(self):
slug = Job(slug='peace-maker-c57fe949')
slug1 = Job(slug='peace-maker-c57fe949')
with self.assertRaises(IntegrityError):
slug.save()
slug1.save()
def test_get_job_by_id(self):
e1 = Event(name = "Software Conference",
start_date = "2012-10-22",
end_date = "2012-10-25")
e1.save()
j1 = Job(name = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job",
event = e1)
j2 = Job(name = "Systems Administrator",
start_date = "2012-9-1",
end_date = "2012-10-26",
description = "A systems administrator job",
event = e1)
j3 = Job(name = "Project Manager",
start_date = "2012-1-2",
end_date = "2012-2-2",
description = "A management job",
event = e1)
j1.save()
j2.save()
j3.save()
#test typical cases
self.assertIsNotNone(get_job_by_id(j1.id))
self.assertIsNotNone(get_job_by_id(j2.id))
self.assertIsNotNone(get_job_by_id(j3.id))
self.assertEqual(get_job_by_id(j1.id), j1)
self.assertEqual(get_job_by_id(j2.id), j2)
self.assertEqual(get_job_by_id(j3.id), j3)
#test non-existant cases
self.assertIsNone(get_job_by_id(100))
self.assertIsNone(get_job_by_id(200))
self.assertIsNone(get_job_by_id(300))
self.assertIsNone(get_job_by_id(400))
self.assertNotEqual(get_job_by_id(100), j1)
self.assertNotEqual(get_job_by_id(100), j2)
self.assertNotEqual(get_job_by_id(100), j3)
self.assertNotEqual(get_job_by_id(200), j1)
self.assertNotEqual(get_job_by_id(200), j2)
self.assertNotEqual(get_job_by_id(200), j3)
self.assertNotEqual(get_job_by_id(300), j1)
self.assertNotEqual(get_job_by_id(300), j2)
self.assertNotEqual(get_job_by_id(300), j3)
def index(request):
if request.user.is_superuser:
record_list = Record.objects.all()
show_operator = True
elif len(Job.objects(users=str(request.user))) != 0:
record_list = []
job_list = [job.name for job in Job.objects(users=str(request.user)).values_list('builders')]
for record in Record.objects.all():
if record.job in job_list:
record_list.append(record)
show_operator = True
else:
record_list = Record.objects.filter(user=str(request.user))
show_operator = False
job_list = []
operator_list = []
result_list = []
for record in record_list:
record.start_time = (datetime.utcfromtimestamp(int(record.start_time)) + timedelta(hours=8)).\
strftime('%Y-%m-%d %H:%M:%S')
job_list.append(record.job)
operator_list.append(record.user)
result_list.append(record.result)
if record.finish_time != 0:
record.finish_time = (datetime.utcfromtimestamp(int(record.finish_time)) + timedelta(hours=8)).\
strftime('%Y-%m-%d %H:%M:%S')
else:
record.finish_time = ''
job_list = sorted(set(job_list))
operator_list = sorted(set(operator_list))
result_list = sorted(set(result_list))
context = {
'record_list': record_list[::-1],
'job_list': job_list,
'operator_list': operator_list,
'result_list': result_list,
'user': request.user,
'show_operator': show_operator,
}
return render(request, 'history/index.html', context)
def do_delete(request, entry_id, recv_data):
user = User.objects.get(id=request.user.id)
ret = {}
if not Entry.objects.filter(id=entry_id).exists():
return HttpResponse('Failed to get an Entry object of specified id',
status=400)
# update name of Entry object
entry = Entry.objects.filter(id=entry_id).get()
if custom_view.is_custom("do_delete_entry", entry.schema.name):
# do_delete custom view
resp = custom_view.call_custom("do_delete_entry", entry.schema.name,
request, user, entry)
# If custom_view returns available response this returns it to user,
# or continues default processing.
if resp:
return resp
# set deleted flag in advance because deleting processing taks long time
entry.is_active = False
entry.save(update_fields=['is_active'])
# save deleting Entry name before do it
ret['name'] = entry.name
# register operation History for deleting entry
user.seth_entry_del(entry)
# Create a new job to delete entry and run it
job_delete_entry = Job.new_delete(user, entry)
job_notify_event = Job.new_notify_delete_entry(user, entry)
# This prioritizes notifying job rather than deleting entry
if job_delete_entry.dependent_job:
job_notify_event.dependent_job = job_delete_entry.dependent_job
job_notify_event.save(update_fields=['dependent_job'])
job_notify_event.run()
# This update dependent job of deleting entry job
job_delete_entry.dependent_job = job_notify_event
job_delete_entry.save(update_fields=['dependent_job'])
job_delete_entry.run()
return JsonResponse(ret)
def post(self, request, entity_id: int):
if not Entity.objects.filter(id=entity_id).exists():
return Response("Failed to get entity of specified id",
status=status.HTTP_400_BAD_REQUEST)
serializer = EntryExportSerializer(data=request.data)
if not serializer.is_valid():
return Response("Parameters in post body is invalid",
status=status.HTTP_400_BAD_REQUEST)
job_params = {
"export_format": serializer.validated_data["format"],
"target_id": entity_id,
}
# check whether same job is sent
job_status_not_finished = [
Job.STATUS["PREPARING"], Job.STATUS["PROCESSING"]
]
if (Job.get_job_with_params(request.user, job_params).filter(
status__in=job_status_not_finished).exists()):
return Response("Same export processing is under execution",
status=status.HTTP_400_BAD_REQUEST)
entity = Entity.objects.get(id=entity_id)
if not request.user.has_permission(entity, ACLType.Readable):
return Response('Permission denied to _value "%s"' % entity.name,
status=status.HTTP_400_BAD_REQUEST)
# create a job to export search result and run it
job = Job.new_export(
request.user,
**{
"text":
"entry_%s.%s" % (entity.name, job_params["export_format"]),
"target": entity,
"params": job_params,
},
)
job.run()
return Response(
{
"result":
"Succeed in registering export processing. " +
"Please check Job list."
},
status=status.HTTP_200_OK,
)
def do_edit(request, entry_id, recv_data):
user = User.objects.get(id=request.user.id)
entry = Entry.objects.get(id=entry_id)
tasks = []
# checks that a same name entry corresponding to the entity is existed.
query = Q(schema=entry.schema, name=recv_data['entry_name']) & ~Q(id=entry.id)
if Entry.objects.filter(query).exists():
return HttpResponse('Duplicate name entry is existed', status=400)
# validate contexts of each attributes
err = _validate_input(recv_data, entry)
if err:
return err
if entry.get_status(Entry.STATUS_CREATING):
return HttpResponse('Target entry is now under processing', status=400)
if custom_view.is_custom("do_edit_entry", entry.schema.name):
# resp is HttpReponse instance or its subclass (e.g. JsonResponse)
resp = custom_view.call_custom(
"do_edit_entry", entry.schema.name, request, recv_data, user, entry
)
if resp:
return resp
# update name of Entry object. If name would be updated, the elasticsearch data of entries that
# refers this entry also be updated by creating REGISTERED_REFERRALS task.
if entry.name != recv_data['entry_name']:
tasks.append(Job.new_register_referrals(user, entry))
entry.name = recv_data['entry_name']
# set flags that indicates target entry is under processing
entry.set_status(Entry.STATUS_EDITING)
entry.save()
# Create a new job to edit entry
tasks.append(Job.new_edit(user, entry, params=recv_data))
# Run all tasks which are created in this request
[t.run() for t in tasks]
return JsonResponse({
'entry_id': entry.id,
'entry_name': entry.name,
})
def post(self, request, *args, **kwargs):
job_data = json.loads(request.body)
if 'company_id' in job_data or 'company' in job_data:
raise serializers.ValidationError('Unexpected Company/Company Id.')
if 'title' not in job_data or not job_data['title']:
raise serializers.ValidationError('Title is required.')
if 'vacancy' not in job_data or not job_data['vacancy']:
raise serializers.ValidationError('Vacancy is required.')
if 'address' not in job_data or not job_data['address']:
raise serializers.ValidationError('Address is required.')
if 'job_site' not in job_data or not job_data['job_site']:
raise serializers.ValidationError('Job site is required.')
if 'job_nature' not in job_data or not job_data['job_nature']:
raise serializers.ValidationError('Job nature is required.')
if 'job_type' not in job_data or not job_data['job_type']:
raise serializers.ValidationError('Job type is required.')
if 'status' in job_data:
if job_data['status'] != 'DRAFT' and job_data[
'status'] != 'POSTED' and job_data['status'] != '':
raise serializers.ValidationError('Invalid status.')
if 'salary_min' in job_data and job_data[
'salary_min'] and 'salary_max' in job_data and job_data[
'salary_max']:
if int(job_data['salary_min']) > int(job_data['salary_max']):
raise serializers.ValidationError(
'Minimum salary cannot be greater than maximum salary')
company = Company.objects.get(user_id=request.user.id)
job_data['company'] = company
try:
skills = job_data['skills']
del job_data['skills']
except KeyError:
skills = None
job_obj = Job(**job_data)
populate_user_info(request, job_obj, False, False)
job_obj.save()
if skills:
skill_list = skills.split(',')
for skill in skill_list:
try:
skill_obj = Skill.objects.get(name=skill)
except Skill.DoesNotExist:
skill_obj = None
if skill_obj:
job_obj.job_skills.add(skill_obj)
return Response(HTTP_200_OK)
def delete(self, request, *args, **kwargs):
# checks mandatory parameters are specified
if not all([x in request.data for x in ['entity', 'entry']]):
return Response('Parameter "entity" and "entry" are mandatory',
status=status.HTTP_400_BAD_REQUEST)
entity = Entity.objects.filter(name=request.data['entity']).first()
if not entity:
return Response('Failed to find specified Entity (%s)' % request.data['entity'],
status=status.HTTP_404_NOT_FOUND)
entry = Entry.objects.filter(name=request.data['entry'], schema=entity).first()
if not entry:
return Response('Failed to find specified Entry (%s)' % request.data['entry'],
status=status.HTTP_404_NOT_FOUND)
# permission check
user = User.objects.get(id=request.user.id)
if (not user.has_permission(entry, ACLType.Full) or
not user.has_permission(entity, ACLType.Readable)):
return Response('Permission denied to operate', status=status.HTTP_400_BAD_REQUEST)
# Delete the specified entry then return its id, if is active
if entry.is_active:
# create a new Job to delete entry and run it
job = Job.new_delete(user, entry)
job.run()
return Response({'id': entry.id})
def do_edit(request, entity_id, recv_data):
entity, error = get_obj_with_check_perm(request.user, Entity, entity_id, ACLType.Writable)
if error:
return error
# validation checks
for attr in recv_data["attrs"]:
# formalize recv_data format
if "ref_ids" not in attr:
attr["ref_ids"] = []
if int(attr["type"]) & AttrTypeValue["object"] and not attr["ref_ids"]:
return HttpResponse("Need to specify enabled referral ids", status=400)
if any([not Entity.objects.filter(id=x).exists() for x in attr["ref_ids"]]):
return HttpResponse("Specified referral is invalid", status=400)
# duplication checks
counter = collections.Counter(
[
attr["name"]
for attr in recv_data["attrs"]
if "deleted" not in attr or not attr["deleted"]
]
)
if len([v for v, count in counter.items() if count > 1]):
return HttpResponse("Duplicated attribute names are not allowed", status=400)
# prevent to show edit page under the processing
if entity.get_status(Entity.STATUS_EDITING):
return HttpResponse("Target entity is now under processing", status=400)
if custom_view.is_custom("edit_entity"):
resp = custom_view.call_custom(
"edit_entity", None, entity, recv_data["name"], recv_data["attrs"]
)
if resp:
return resp
# update status parameters
if recv_data["is_toplevel"]:
entity.set_status(Entity.STATUS_TOP_LEVEL)
else:
entity.del_status(Entity.STATUS_TOP_LEVEL)
# update entity metatada informations to new ones
entity.set_status(Entity.STATUS_EDITING)
# Create a new job to edit entity and run it
job = Job.new_edit_entity(request.user, entity, params=recv_data)
job.run()
new_name = recv_data["name"]
return JsonResponse(
{
"entity_id": entity.id,
"entity_name": new_name,
"msg": 'Success to schedule to update Entity "%s"' % new_name,
}
)
def do_delete(request, entity_id, recv_data):
entity, error = get_obj_with_check_perm(request.user, Entity, entity_id, ACLType.Full)
if error:
return error
if not entity.is_active:
return HttpResponse("Target entity is now under processing", status=400)
if Entry.objects.filter(schema=entity, is_active=True).exists():
return HttpResponse(
"cannot delete Entity because one or more Entries are not deleted",
status=400,
)
if custom_view.is_custom("delete_entity"):
resp = custom_view.call_custom("delete_entity", None, entity)
if resp:
return resp
ret = {}
# save deleting target name before do it
ret["name"] = entity.name
# set deleted flag in advance because deleting processing takes long time
entity.is_active = False
entity.save(update_fields=["is_active"])
# Create a new job to delete entry and run it
job = Job.new_delete_entity(request.user, entity)
job.run()
return JsonResponse(ret)
def test_cancel_job(self):
user = self.guest_login()
entity = Entity.objects.create(name='entity', created_user=user)
entry = Entry.objects.create(name='entry', schema=entity, created_user=user)
# make a job
job = Job.new_delete(user, entry)
self.assertEqual(job.status, Job.STATUS['PREPARING'])
# send request without any parameters
resp = self.client.delete('/api/v1/job/', json.dumps({}), 'application/json')
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content, b'"Parameter job_id is required"')
# send request with invalid job id
resp = self.client.delete('/api/v1/job/', json.dumps({'job_id': 99999}), 'application/json')
self.assertEqual(resp.status_code, 400)
self.assertEqual(resp.content, b'"Failed to find Job(id=99999)"')
# send request with proper parameter
resp = self.client.delete('/api/v1/job/', json.dumps({'job_id': job.id}),
'application/json')
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to cancel job"')
job.refresh_from_db()
self.assertEqual(job.status, Job.STATUS['CANCELED'])
def get_queryset(self):
search_query = self.request.query_params.get('q', None)
queryset = Job.search(self.request.query_params)
user = self.request.user
profile = user.profile if hasattr(user, 'profile') else Profile(
user=user)
return queryset.filter(favorites__id=profile.id)
def test_get_search_job(self):
user = self.guest_login()
entity = Entity.objects.create(name="entity", created_user=user)
entry = Entry.objects.create(name="entry", schema=entity, created_user=user)
# make a job
job = Job.new_delete(user, entry)
# send request without any GET parameters
resp = self.client.get("/api/v1/job/search")
self.assertEqual(resp.status_code, 400)
# send request with a GET parameter that doesn't match any job
resp = self.client.get("/api/v1/job/search", {"operation": JobOperation.COPY_ENTRY.value})
self.assertEqual(resp.status_code, 404)
# send requests with GET parameter that matches the created job
for param in [
{"operation": JobOperation.DELETE_ENTRY.value},
{"target_id": entry.id},
]:
resp = self.client.get("/api/v1/job/search", param)
self.assertEqual(resp.status_code, 200)
self.assertEqual(len(resp.json()), 1)
self.assertEqual(resp.json()["result"][0]["id"], job.id)
self.assertEqual(resp.json()["result"][0]["target"]["id"], entry.id)
def do_import_data(request, entity_id, context):
user = User.objects.get(id=request.user.id)
entity = Entity.objects.filter(id=entity_id, is_active=True).first()
if not entity:
return HttpResponse("Couldn't parse uploaded file", status=400)
try:
data = yaml.load(context, Loader=yaml.FullLoader)
except yaml.parser.ParserError:
return HttpResponse("Couldn't parse uploaded file", status=400)
if not Entry.is_importable_data(data):
return HttpResponse("Uploaded file has invalid data structure to import", status=400)
if custom_view.is_custom("import_entry", entity.name):
# import custom view
resp = custom_view.call_custom("import_entry", entity.name, user, entity, data)
# If custom_view returns available response this returns it to user,
# or continues default processing.
if resp:
return resp
# create job to import data to create or update entries and run it
job = Job.new_import(user, entity, text='Preparing to import data', params=data)
job.run()
return HttpResponseSeeOther('/entry/%s/' % entity_id)
def post(self, request):
import_datas = request.data
user: User = request.user
serializer = EntryImportSerializer(data=import_datas)
serializer.is_valid(raise_exception=True)
job_ids = []
error_list = []
for import_data in import_datas:
entity = Entity.objects.filter(name=import_data["entity"],
is_active=True).first()
if not entity:
error_list.append("%s: Entity does not exists." %
import_data["entity"])
continue
if not user.has_permission(entity, ACLType.Writable):
error_list.append("%s: Entity is permission denied." %
import_data["entity"])
continue
job = Job.new_import_v2(user,
entity,
text="Preparing to import data",
params=import_data)
job.run()
job_ids.append(job.id)
return Response({"result": {
"job_ids": job_ids,
"error": error_list
}},
status=status.HTTP_200_OK)
def destroy(self, request, pk):
entry: Entry = self.get_object()
if not entry.is_active:
raise ValidationError("specified entry has already been deleted")
user: User = request.user
if custom_view.is_custom("before_delete_entry_v2", entry.schema.name):
custom_view.call_custom("before_delete_entry_v2",
entry.schema.name, user, entry)
# register operation History for deleting entry
user.seth_entry_del(entry)
# delete entry
entry.delete(deleted_user=user)
if custom_view.is_custom("after_delete_entry_v2", entry.schema.name):
custom_view.call_custom("after_delete_entry_v2", entry.schema.name,
user, entry)
# Send notification to the webhook URL
job_notify: Job = Job.new_notify_delete_entry(user, entry)
job_notify.run()
return Response(status=status.HTTP_204_NO_CONTENT)
class ReadTest(TestCase):
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.title = 'Test'
self.area = 'DESIGN'
self.description = 'Testing...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.job = Job(project=self.project, title=self.title, area=self.area,
description=self.description)
self.job.save()
self.client.login(username=self.username, password=self.passwd)
def test_login_required(self):
self.client.logout()
response = self.client.get(READ_URL % self.job.id)
self.assertRedirects(response, LOGIN_URL + '?next=' + READ_URL % self.job.id)
def test_get(self):
response = self.client.get(READ_URL % self.job.id)
self.assertEqual(response.status_code, 200)
def test_invalid_id(self):
response = self.client.get(READ_URL % '2')
self.assertEqual(response.status_code, 404)
def test_deactivated_project(self):
self.project.is_active = False
self.project.save()
response = self.client.get(READ_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project_author(self):
username = '******'
email = '*****@*****.**'
passwd = 'abc'
user = User.objects.create_user(username, email, passwd)
self.client.logout()
self.client.login(username=username, password=passwd)
self.project.author.is_active = False
self.project.author.save()
response = self.client.get(READ_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def import_jobs(request):
context_vars = dict()
context_vars['header'] = capfirst(_('import jobs from workflowmax'))
context_vars['comment'] = capfirst(_('this will destroy all your local jobs, please confirm your decision.'))
if request.method == "POST":
try:
for job in Job.objects.all():
job.delete()
wm_jobs = WorkflowmaxJob.objects.all(datetime.now() - timedelta(days=365), datetime.now() + timedelta(days=365))
# wm_jobs = WorkflowmaxJob.objects.current()
for wm_job in wm_jobs:
job = Job()
job.wm_import(wm_job)
messages.success(request, capfirst(_('jobs were imported successfully')), fail_silently=True)
return HttpResponseRedirect(reverse('job-list'))
except NoInitialData, e:
context_vars['error'] = capfirst(e)
def test_delete_shift(self):
""" Test delete_shift(shift_id) """
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j1.save()
s1 = Shift(date="2012-10-23", start_time="1:00", end_time="12:00", max_volunteers=1, job=j1)
s2 = Shift(date="2011-11-11", start_time="11:00", end_time="12:00", max_volunteers=3, job=j1)
s1.save()
s2.save()
self.assertTrue(delete_shift(s1.id))
self.assertFalse(delete_shift(100))
register(v1.id, s2.id)
self.assertFalse(delete_shift(s2.id))
def test_get_jobs_by_event_id(self):
""" Test get_jobs_by_event_id(e_id) """
e1 = Event(
name="Software Conference",
start_date="2012-10-22",
end_date="2012-10-25"
)
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1
)
j3 = Job(
name="Project Manager",
start_date="2012-1-2",
end_date="2012-2-2",
description="A management job",
event=e1
)
j1.save()
j2.save()
j3.save()
# test typical case
job_list = get_jobs_by_event_id(e1.id)
self.assertIsNotNone(job_list)
self.assertNotEqual(job_list, False)
self.assertEqual(len(job_list), 3)
self.assertIn(j1, job_list)
self.assertIn(j2, job_list)
self.assertIn(j3, job_list)
def test_delete_job(self):
""" Test delete_job(job_id) """
e1 = Event(
name="Software Conference",
start_date="2012-10-22",
end_date="2012-10-25"
)
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1
)
j3 = Job(
name="Project Manager",
start_date="2012-1-2",
end_date="2012-2-2",
description="A management job",
event=e1
)
j1.save()
j2.save()
j3.save()
# test typical cases
self.assertTrue(delete_job(j1.id))
self.assertTrue(delete_job(j2.id))
self.assertTrue(delete_job(j3.id))
self.assertFalse(delete_job(100))
self.assertFalse(delete_job(200))
self.assertFalse(delete_job(300))
def test_get_event_by_shift_id(self):
e1 = Event(
name="Open Source Event",
start_date="2012-10-22",
end_date="2012-10-23"
)
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1
)
j1.save()
j2.save()
s1 = Shift(
date="2012-10-23",
start_time="9:00",
end_time="3:00",
max_volunteers=1,
job=j1
)
s2 = Shift(
date="2012-10-23",
start_time="10:00",
end_time="4:00",
max_volunteers=2,
job=j1
)
s3 = Shift(
date="2012-10-23",
start_time="12:00",
end_time="6:00",
max_volunteers=4,
job=j2
)
s1.save()
s2.save()
s3.save()
self.assertIsNotNone(get_event_by_shift_id(s1.id))
self.assertIsNotNone(get_event_by_shift_id(s2.id))
self.assertIsNotNone(get_event_by_shift_id(s3.id))
def get_valid_staff(request):
skill = request.GET.get('skill', '')
if not skill:
return HttpResponse('', mimetype="application/json")
start_date = request.GET.get('start', '')
due_date = request.GET.get('due', '')
for format in formats.get_format('DATETIME_INPUT_FORMATS'):
try:
start_date = datetime.strptime(start_date, format)
due_date = datetime.strptime(due_date, format)
except ValueError:
continue
skill = get_object_or_404(Skill, id=skill)
job = Job()
job.type = skill
job.start_date = start_date
job.due_date = due_date
staff = job.get_valid_staff()
staff_list = []
for staff_obj in staff:
staff_list.append((staff_obj.id, staff_obj.username))
json = simplejson.dumps(staff_list)
return HttpResponse(json, mimetype="application/json")
def run(self):
counter = 0
for job in self.jobs:
new_job = Job(
title=job.title,
description=job.description,
employer=self.profile,
availability=job.availability,
experience=job.experience,
education=job.education,
employment_type=job.employment_type,
overtime=job.overtime,
latitude=job.latitude,
longitude=job.longitude,
)
new_job.save()
new_job.workday = job.workday.all()
new_job.industry = job.industry.all()
new_job.save()
new_location = JobLocation(
business_name=job.location.business_name,
business_address1=job.location.business_address1,
business_address2=job.location.business_address2,
city=job.location.city,
zip_code=job.location.zip_code,
latitude=job.location.latitude,
longitude=job.location.longitude,
job=new_job,
)
new_location.save()
for existing_profile in self.profiles:
rec = JobRecommendation(
job=new_job,
applicant=existing_profile,
state=(JobRecommendation.NEW_REC_SENT if counter > 2 else JobRecommendation.APPLIED_REC),
)
rec.save()
if counter <= 2:
application = ApplicantJob(job=new_job, applicant=existing_profile, send_email=False)
application.save()
if existing_profile.id == 24 and job.id == 12:
application = ApplicantJob(job=new_job, applicant=existing_profile, send_email=False)
application.save()
counter = counter + 1
counter = 0
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.title = 'Test'
self.area = 'DESIGN'
self.description = 'Testing...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.job = Job(project=self.project, title=self.title, area=self.area,
description=self.description)
self.job.save()
self.client.login(username=self.username, password=self.passwd)
def index(request):
if request.user.is_superuser:
job_list = Job.objects.all()
server_list = Server.objects.all()
else:
job_list = Job.objects(users=str(request.user))
server_list = Server.objects(users=str(request.user))
user_list = User.objects.all()
context = {
'job_list': job_list,
'server_list': server_list,
'user_list': user_list
}
return render(request, 'permission/index.html', context)
def test_get_shifts_with_open_slots(self):
""" Test get_shifts_with_open_slots(j_id) """
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1,
)
j1.save()
j2.save()
s1 = Shift(date="2012-10-23", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)
s2 = Shift(date="2012-10-23", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)
s3 = Shift(date="2012-10-23", start_time="12:00", end_time="6:00", max_volunteers=4, job=j2)
s1.save()
s2.save()
s3.save()
self.assertIsNotNone(get_shifts_with_open_slots(j1.id))
self.assertIsNotNone(get_shifts_with_open_slots(j2.id))
class DeleteTest(TestCase):
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.title = 'Test'
self.area = 'DESIGN'
self.description = 'Testing...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.job = Job(project=self.project, title=self.title, area=self.area,
description=self.description)
self.job.save()
self.client.login(username=self.username, password=self.passwd)
def test_login_required(self):
self.client.logout()
response = self.client.get(DELETE_URL % self.job.id)
self.assertRedirects(response, LOGIN_URL + '?next=' + \
DELETE_URL % self.job.id)
def test_get(self):
response = self.client.get(DELETE_URL % self.job.id)
self.assertEqual(response.status_code, 200)
def test_post(self):
self.client.post(DELETE_URL % self.job.id)
self.assertEqual(Job.objects.filter(is_active=True).count(), 0)
def test_next(self):
response = self.client.post(DELETE_URL % self.job.id + '?next=' + LOGIN_URL)
self.assertRedirects(response, LOGIN_URL + '?job-delete=True')
def test_invalid_id(self):
response = self.client.get(DELETE_URL % '2')
self.assertEqual(response.status_code, 404)
def test_invalid_author(self):
self.client.logout()
User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.client.login(username='******', password='******')
response = self.client.get(DELETE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project(self):
self.project.is_active = False
self.project.save()
response = self.client.get(DELETE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project_author(self):
self.client.logout()
user = User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.job.author = user
self.job.save()
self.project.author.is_active = False
self.project.save()
self.client.login(username='******', password='******')
response = self.client.get(DELETE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_get_shift_by_id(self):
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j1.save()
s1 = Shift(date = "2012-10-23",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 1,
job = j1)
s2 = Shift(date = "2012-10-23",
location = "Infinite Loop",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
slots_remaining = 2,
job = j1)
s3 = Shift(date = "2012-10-23",
location = "Loopy Loop Road",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
slots_remaining = 4,
job = j1)
s1.save()
s2.save()
s3.save()
#test typical cases
self.assertIsNotNone(get_shift_by_id(s1.id))
self.assertIsNotNone(get_shift_by_id(s2.id))
self.assertIsNotNone(get_shift_by_id(s3.id))
self.assertEqual(get_shift_by_id(s1.id), s1)
self.assertEqual(get_shift_by_id(s2.id), s2)
self.assertEqual(get_shift_by_id(s3.id), s3)
#test non-existant cases
self.assertIsNone(get_shift_by_id(100))
self.assertIsNone(get_shift_by_id(200))
self.assertIsNone(get_shift_by_id(300))
self.assertIsNone(get_shift_by_id(400))
self.assertNotEqual(get_shift_by_id(100), s1)
self.assertNotEqual(get_shift_by_id(100), s2)
self.assertNotEqual(get_shift_by_id(100), s3)
self.assertNotEqual(get_shift_by_id(200), s1)
self.assertNotEqual(get_shift_by_id(200), s2)
self.assertNotEqual(get_shift_by_id(200), s3)
self.assertNotEqual(get_shift_by_id(300), s1)
self.assertNotEqual(get_shift_by_id(300), s2)
self.assertNotEqual(get_shift_by_id(300), s3)
def test_get_shifts_signed_up_for(self):
u1 = User.objects.create_user('Yoshi')
v1 = Volunteer(first_name = "Yoshi",
last_name = "Turtle",
address = "Mario Land",
city = "Nintendo Land",
state = "Nintendo State",
country = "Nintendo Nation",
phone_number = "2374983247",
email = "*****@*****.**",
user = u1)
v1.save()
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j2 = Job(job_title = "Systems Administrator",
start_date = "2012-9-1",
end_date = "2012-10-26",
description = "A systems administrator job")
j1.save()
j2.save()
s1 = Shift(date = "2012-10-23",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 1,
job = j1)
s2 = Shift(date = "2012-10-23",
location = "Infinite Loop",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
slots_remaining = 2,
job = j1)
s3 = Shift(date = "2012-10-23",
location = "Loopy Loop Road",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
slots_remaining = 4,
job = j2)
s1.save()
s2.save()
s3.save()
#sign up
register(v1.id, s1.id)
register(v1.id, s2.id)
register(v1.id, s3.id)
#test typical case
shift_list = get_shifts_signed_up_for(v1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 3)
self.assertIn(s1, shift_list)
self.assertIn(s2, shift_list)
self.assertIn(s3, shift_list)
def test_has_slots_remaining(self):
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j1.save()
s1 = Shift(date = "2012-10-23",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 1,
job = j1)
s2 = Shift(date = "2012-10-23",
location = "Infinite Loop",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
slots_remaining = 2,
job = j1)
s3 = Shift(date = "2012-10-23",
location = "Loopy Loop Road",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
slots_remaining = 4,
job = j1)
s1.save()
s2.save()
s3.save()
self.assertTrue(has_slots_remaining(s1))
self.assertTrue(has_slots_remaining(s2))
self.assertTrue(has_slots_remaining(s3))
decrement_slots_remaining(s1)
self.assertFalse(has_slots_remaining(s1))
decrement_slots_remaining(s2)
self.assertTrue(has_slots_remaining(s2))
decrement_slots_remaining(s2)
self.assertFalse(has_slots_remaining(s2))
decrement_slots_remaining(s3)
self.assertTrue(has_slots_remaining(s3))
decrement_slots_remaining(s3)
self.assertTrue(has_slots_remaining(s3))
decrement_slots_remaining(s3)
self.assertTrue(has_slots_remaining(s3))
decrement_slots_remaining(s3)
self.assertFalse(has_slots_remaining(s3))
self.assertEqual(s1.slots_remaining, 0)
self.assertEqual(s2.slots_remaining, 0)
self.assertEqual(s3.slots_remaining, 0)
def test_register(self):
u1 = User.objects.create_user('Yoshi')
u2 = User.objects.create_user('John')
v1 = Volunteer(first_name = "Yoshi",
last_name = "Turtle",
address = "Mario Land",
city = "Nintendo Land",
state = "Nintendo State",
country = "Nintendo Nation",
phone_number = "2374983247",
email = "*****@*****.**",
user = u1)
v2 = Volunteer(first_name = "John",
last_name = "Doe",
address = "7 Alpine Street",
city = "Maplegrove",
state = "Wyoming",
country = "USA",
phone_number = "23454545",
email = "*****@*****.**",
user = u2)
v1.save()
v2.save()
j1 = Job(job_title = "Software Developer",
start_date = "2012-10-22",
end_date = "2012-10-23",
description = "A software job")
j2 = Job(job_title = "Systems Administrator",
start_date = "2012-9-1",
end_date = "2012-10-26",
description = "A systems administrator job")
j1.save()
j2.save()
s1 = Shift(date = "2012-10-23",
location = "Google Drive",
start_time = "9:00",
end_time = "3:00",
max_volunteers = 1,
slots_remaining = 1,
job = j1)
s2 = Shift(date = "2012-10-23",
location = "Infinite Loop",
start_time = "10:00",
end_time = "4:00",
max_volunteers = 2,
slots_remaining = 2,
job = j1)
s3 = Shift(date = "2012-10-23",
location = "Loopy Loop Road",
start_time = "12:00",
end_time = "6:00",
max_volunteers = 4,
slots_remaining = 4,
job = j2)
s1.save()
s2.save()
s3.save()
#test typical cases
self.assertTrue(register(v1.id, s1.id))
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id))
self.assertTrue(register(v1.id, s2.id))
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id))
self.assertTrue(register(v1.id, s3.id))
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id))
#test cases where volunteer tries to sign up for a shift they are already signed up for
self.assertFalse(register(v1.id, s1.id))
self.assertFalse(register(v1.id, s2.id))
self.assertFalse(register(v1.id, s3.id))
#test case where more than one volunteer signs up for the same shift
#v2 can't sign up for s1 because there are no slots remaining
self.assertFalse(register(v2.id, s1.id))
self.assertTrue(register(v2.id, s2.id))
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v2.id, shift_id=s2.id))
self.assertTrue(register(v2.id, s3.id))
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v2.id, shift_id=s3.id))
#test cases where a volunteer tries to sign up for a shift they are already signed up for
self.assertFalse(register(v2.id, s2.id))
self.assertFalse(register(v2.id, s3.id))
class UpdateTest(TestCase):
def setUp(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.passwd = 'passwd'
self.title = 'Test'
self.new_title = 'Testing'
self.area = 'DESIGN'
self.new_area = 'ADM'
self.description = 'Testing...'
self.new_description = 'Test...'
user = User.objects.create_user(self.username, self.email, self.passwd)
self.project = Project(author=user)
self.project.save()
self.job = Job(project=self.project, title=self.title, area=self.area,
description=self.description)
self.job.save()
self.client.login(username=self.username, password=self.passwd)
def test_login_required(self):
self.client.logout()
response = self.client.get(UPDATE_URL % self.job.id)
self.assertRedirects(response, LOGIN_URL + '?next=' + \
UPDATE_URL % self.job.id)
def test_get(self):
response = self.client.get(UPDATE_URL % self.job.id)
self.assertEqual(response.status_code, 200)
def test_post(self):
self.client.post(UPDATE_URL % self.job.id,
{
'title': self.new_title,
'area': self.new_area,
'description': self.new_description,
})
job = Job.objects.get(id=self.job.id)
self.assertEqual(job.is_active, True)
self.assertEqual(job.created, date.today())
self.assertEqual(job.title, self.new_title)
self.assertEqual(job.area, self.new_area)
self.assertEqual(job.description, self.new_description)
def test_next(self):
response = self.client.post(UPDATE_URL % self.job.id + \
'?next=' + LOGIN_URL, {
'title': self.new_title,
'area': self.new_area,
'description': self.new_description,
})
self.assertRedirects(response, LOGIN_URL + '?job-update=True')
def test_invalid_id(self):
response = self.client.get(UPDATE_URL % '2')
self.assertEqual(response.status_code, 404)
def test_invalid_author(self):
self.client.logout()
User.objects.create_user('*****@*****.**', '*****@*****.**', 'abc')
self.client.login(username='******', password='******')
response = self.client.get(UPDATE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project(self):
self.project.is_active = False
self.project.save()
response = self.client.get(UPDATE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
def test_deactivated_project_author(self):
username = '******'
email = '*****@*****.**'
passwd = 'abc'
user = User.objects.create_user(username, email, passwd)
self.client.logout()
self.client.login(username=username, password=passwd)
self.project.author.is_active = False
self.project.author.save()
response = self.client.get(UPDATE_URL % self.job.id)
self.assertEqual(response.status_code, 404)
