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)