def setUpClass(cls):
super(GraphsTestCase, cls).setUpClass()
cls.factory = RequestFactory()
Request(path="/admin/", ip="127.0.0.1").save()
Request(path="/admin/", ip="127.0.0.1").save()
Request(path="/admin/login/", ip="127.0.0.1").save()
staff_user = User.objects.create_user(username="******", password="******")
staff_user.is_staff = True
staff_user.save()
cls.staff_user = staff_user
cls.coordinator = EditorFactory(user__email="*****@*****.**").user
coordinators = get_coordinators()
coordinators.user_set.add(cls.coordinator)
user = UserFactory()
cls.user = user
cls.partner = PartnerFactory()
cls.app = ApplicationFactory(partner=cls.partner)
cls.app.status = Application.APPROVED
cls.app.save()
cls.dashboard_url = reverse("dashboard")
def test_browser_detection_with_no_path(self):
request = Request(
user_agent=
'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:43.0) Gecko/20100101 Firefox/43.0'
)
self.assertEqual(request.browser, 'Firefox')
request = Request(
user_agent=
'Mozilla/5.0 (compatible; MSIE 9.0; America Online Browser 1.1; Windows NT 5.0)'
)
self.assertEqual(request.browser, 'AOL')
def setUpClass(cls):
super(GraphsTestCase, cls).setUpClass()
cls.factory = RequestFactory()
Request(path='/admin/', ip='127.0.0.1').save()
Request(path='/admin/', ip='127.0.0.1').save()
Request(path='/admin/login/', ip='127.0.0.1').save()
user = User.objects.create_user(username='******', password='******')
user.is_staff = True
user.save()
cls.staff_user = user
def test_from_http_request_with_user(self):
http_request = self.factory.get('/')
http_request.user = get_user_model().objects.create(username='******')
request = Request()
request.from_http_request(http_request, commit=False)
self.assertEqual(request.user.id, http_request.user.id)
def process_response(self, request, response):
if request.method.lower() not in settings.REQUEST_VALID_METHOD_NAMES:
return response
if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
return response
ignore = patterns(False, *settings.REQUEST_IGNORE_PATHS)
if ignore.resolve(request.path[1:]):
return response
if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
return response
if get_remote_addr(request) in settings.REQUEST_IGNORE_IP:
return response
if getattr(request, 'user', False):
if request.user.username in settings.REQUEST_IGNORE_USERNAME:
return response
r = Request()
r.from_http_request(request, response)
return response
def process_response(self, request, response):
if request.method.lower() not in settings.VALID_METHOD_NAMES:
return response
if response.status_code < 400 and settings.ONLY_ERRORS:
return response
ignore = patterns(False, *settings.IGNORE_PATHS)
if ignore.resolve(request.path[1:]):
return response
if request.is_ajax() and settings.IGNORE_AJAX:
return response
if request.META.get('REMOTE_ADDR') in settings.IGNORE_IP:
return response
ignore = patterns(False, *settings.IGNORE_USER_AGENTS)
if ignore.resolve(request.META.get('HTTP_USER_AGENT', '')):
return response
if getattr(request, 'user', False):
if request.user.username in settings.IGNORE_USERNAME:
return response
r = Request()
r.from_http_request(request, response)
return response
def test_from_http_request_not_commit(self):
http_request = HttpRequest()
http_request.method = 'GET'
request = Request()
request.from_http_request(http_request, commit=False)
self.assertIsNone(request.id)
def test_from_http_request_with_user(self):
http_request = HttpRequest()
http_request.method = 'GET'
http_request.user = get_user_model().objects.create(username='******')
request = Request()
request.from_http_request(http_request, commit=False)
self.assertEqual(request.user.id, http_request.user.id)
def setUp(self):
self.user = self.create_user('*****@*****.**', 'foo-foo')
self.client.login(email='*****@*****.**', password='******')
self.sample = create_sample(self._get_random_name())
self.request = Request(user=self.user)
self.request.save()
self.request.samples.add(self.sample)
def test_from_http_request_with_user(self):
http_request = HttpRequest()
http_request.method = 'GET'
http_request.user = User.objects.create(username='******')
request = Request()
request.from_http_request(http_request)
self.assertEqual(request.user.id, http_request.user.id)
def test_from_http_request_redirection(self):
http_request = HttpRequest()
http_request.method = 'GET'
http_response = HttpResponse(status=301)
http_response['Location'] = '/foo'
request = Request()
request.from_http_request(http_request, http_response)
self.assertEqual(request.redirect, '/foo')
def test_from_http_request_redirection(self):
http_request = self.factory.get('/')
http_response = HttpResponse(status=301)
http_response['Location'] = '/foo'
request = Request()
request.from_http_request(http_request, http_response, commit=False)
self.assertEqual(request.redirect, '/foo')
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_staff=True,
)
user.save()
self.request = Request(user=user)
self.request.save()
def create_library_preparation_obj(sample_name, user, sample_status):
sample = create_sample(sample_name, status=sample_status)
sample.save()
request = Request(user=user)
request.save()
request.samples.add(sample)
pool = create_pool(user)
pool.samples.add(sample)
return LibraryPreparation.objects.get(sample=sample)
def create_interview(request):
positions = PositionAll.objects.all()
existing_order = get_user_pending_order(request)
cart_amount = ''
if existing_order!=0:
cart_amount = existing_order.items.all().count()
else:
return redirect(reverse('candidate_cart:order_summary'))
if request.method == 'POST':
request_id = generate_request_id()
request_title = request.POST.get('request_title')
date_interview = request.POST.get('date_interview')
note_interview = request.POST.get('note_interview')
request_position_id = request.POST.get('request_position')
request_position_other = request.POST.get('request_position_other_name')
print(request_position_id,"||||||||||",request_position_other)
request_position = get_object_or_404(PositionAll, position_id=request_position_id)
user_profile = get_object_or_404(Profile, user=request.user)
user_order = Order.objects.get(owner=user_profile, is_ordered=False)
status = get_object_or_404(Status, status_id='1')
request_type = get_object_or_404(RequestType, request_type_id='2')
existing_order = get_user_pending_order(request)
if existing_order!=0:
request_interview = RequestInterview(order = user_order,date_interview = date_interview,note_interview =note_interview)
request_interview.save()
request_detail = Request(request_id=request_id,request_type=request_type,request_interview=request_interview,request_title=request_title,request_position=request_position,request_position_other=request_position_other,owner=user_profile,status=status)
request_detail.save()
# context = {
# 'order': existing_order,
# 'Cart_amount': cart_amount,
# }
#
# return render(request, 'create-interview.html', context)
return redirect(reverse('candidate_cart:update_interview',
kwargs={
'order_id': user_order.ref_code
})
)
context = {
'Positions' : positions,
'order': existing_order,
'Cart_amount': cart_amount,
}
return render(request, 'create-interview.html', context)
def setUpClass(cls):
super(GraphsTestCase, cls).setUpClass()
cls.factory = RequestFactory()
Request(path='/admin/', ip='127.0.0.1').save()
Request(path='/admin/', ip='127.0.0.1').save()
Request(path='/admin/login/', ip='127.0.0.1').save()
staff_user = User.objects.create_user(username='******', password='******')
staff_user.is_staff = True
staff_user.save()
cls.staff_user = staff_user
user = UserFactory()
cls.user = user
cls.partner = PartnerFactory()
cls.app = ApplicationFactory(partner=cls.partner)
cls.app.status = Application.APPROVED
cls.app.save()
cls.dashboard_url = reverse('dashboard')
def create_test_client_and_request(self):
client = Client(name="client A")
data = [
Request(title=f'title {index+1}',
description=f'description {index+1}',
client_id=1,
priority=index + 1,
target_date=date(2018, 11, 6),
product=product)
for index, product in enumerate(ProductEnum)
]
data.append(client)
db.session.add_all(data)
db.session.commit()
def setUp(self):
user = self.create_user()
self.create_user('*****@*****.**', 'test', False) # non-staff user
# Submission completed
self.library1 = create_library(self._get_random_name(), status=1)
self.sample1 = create_sample(self._get_random_name(), status=1)
self.sample2 = create_sample(self._get_random_name(), status=1)
# Failed library
self.library2 = create_library(self._get_random_name(), status=-1)
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(*[self.library1, self.library2])
self.request.samples.add(*[self.sample1, self.sample2])
def setUp(self):
user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_staff=self._is_staff,
)
user.save()
library = Library.get_test_library('Library')
sample = Sample.get_test_sample('Sample')
library.save()
sample.save()
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(library)
self.request.samples.add(sample)
def create_pooling_object(user,
save=True,
add_library=False,
add_sample=False,
sample_failed=False):
library = None
sample = None
if add_library:
library = create_library(get_random_name(), 2)
if add_sample:
sample = create_sample(get_random_name(), 2)
pool = create_pool(user)
request = Request(user=user)
request.save()
if library:
request.libraries.add(library)
pool.libraries.add(library)
pooling_object = Pooling.objects.get(library=library)
if sample:
request.samples.add(sample)
pool.samples.add(sample)
# Update the sample instance because after being added to the pool,
# it was modified
sample = sample.__class__.objects.get(pk=sample.pk)
if sample_failed:
sample.status = -1 # failed quality check
sample.save()
pooling_object = sample
else:
sample.status = 3 # passed quality check
sample.save()
pooling_object = Pooling.objects.get(sample=sample)
if save:
pooling_object.save()
return pooling_object
def test_multiple_sample_contains_invalid(self):
"""
Ensure get multiple samples containing invalid ids behaves correctly.
"""
sample = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(sample)
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample.pk, 'blah'])
})
data = response.json()
self.assertEqual(response.status_code, 400)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'Invalid payload.')
def test_from_http_request(self):
http_request = self.factory.patch(
'/kylef',
REMOTE_ADDR='32.64.128.16',
HTTP_USER_AGENT='test user agent',
HTTP_REFERER='https://fuller.li/',
)
http_response = HttpResponse(status=204)
request = Request()
request.from_http_request(http_request, http_response, commit=False)
self.assertEqual(request.path, '/kylef')
self.assertEqual(request.method, 'PATCH')
self.assertEqual(request.ip, '32.64.128.16')
self.assertEqual(request.response, 204)
self.assertEqual(request.user_agent, 'test user agent')
self.assertEqual(request.referer, 'https://fuller.li/')
def test_from_http_request(self):
http_request = HttpRequest()
http_request.method = 'PATCH'
http_request.path = '/kylef'
http_request.META['REMOTE_ADDR'] = '32.64.128.16'
http_request.META['HTTP_USER_AGENT'] = 'test user agent'
http_request.META['HTTP_REFERER'] = 'https://fuller.li/'
http_response = HttpResponse(status=204)
request = Request()
request.from_http_request(http_request, http_response, commit=False)
self.assertEqual(request.path, '/kylef')
self.assertEqual(request.method, 'PATCH')
self.assertEqual(request.ip, '32.64.128.16')
self.assertEqual(request.response, 204)
self.assertEqual(request.user_agent, 'test user agent')
self.assertEqual(request.referer, 'https://fuller.li/')
def test_multiple_samples(self):
""" Ensure get multiple samples behaves correctly. """
sample1 = create_sample(get_random_name())
sample2 = create_sample(get_random_name())
sample3 = create_sample(get_random_name())
request = Request(user=self.user)
request.save()
request.samples.add(*[sample1.pk, sample2.pk, sample3.pk])
response = self.client.get(reverse('samples-list'), {
'request_id': request.pk,
'ids': json.dumps([sample1.pk, sample2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
samples = [x['name'] for x in data['data']]
self.assertIn(sample1.name, samples)
self.assertIn(sample2.name, samples)
self.assertNotIn(sample3.name, samples)
def test_multiple_libraries(self):
""" Ensure get multiple libraries behaves correctly. """
library1 = create_library(get_random_name())
library2 = create_library(get_random_name())
library3 = create_library(get_random_name())
request = Request(user=self.user)
request.save()
request.libraries.add(*[library1.pk, library2.pk, library3.pk])
response = self.client.get(
reverse('libraries-list'), {
'request_id': request.pk,
'ids': json.dumps([library1.pk, library2.pk])
})
data = response.json()
self.assertEqual(response.status_code, 200)
self.assertTrue(data['success'])
libraries = [x['name'] for x in data['data']]
self.assertIn(library1.name, libraries)
self.assertIn(library2.name, libraries)
self.assertNotIn(library3.name, libraries)
def setUp(self):
user = User.objects.create_user(email='*****@*****.**', password='******')
pool = Pool(name='_Foo', user=user)
pool.save()
library_1 = Library.get_test_library('Library1')
library_2 = Library.get_test_library('Library2')
library_1.save()
library_2.save()
sample_1 = Sample.get_test_sample('Sample1')
sample_2 = Sample.get_test_sample('Sample2')
sample_1.save()
sample_2.save()
pool.libraries.add(library_1)
pool.samples.add(sample_1)
self.request = Request(user=user)
self.request.save()
self.request.libraries.add(*[library_1, library_2])
self.request.samples.add(*[sample_1, sample_2])
def create_request(request):
# authenticate
if not check_logged_in(request):
return redirect('access_denied')
# get user
user = User.objects.get(id=request.session.get("user_id"))
# handle new requests
if request.method == 'GET':
context = {
'group_id': user.group.name,
'tags': [x.name for x in Tag.objects.all()],
}
return render(request, "request/create_request.html", context)
if request.method == 'POST':
try:
new_request = Request(
status=request.POST.get("requestStatus", None),
title=request.POST.get("request-title", None),
request_message=request.POST.get("request-message", None),
requester=user,
group=user.group,
response_message=request.POST.get("response-message", None),
)
new_request.clean()
new_request.save()
new_tags = [Tag.objects.get(name=tag_name) for tag_name in request.POST.getlist("details-tags", None)]
new_request.tags.set(new_tags)
return redirect('dashboard')
except ValidationError as error:
context = {
'group_id': user.group.name,
'tags': [x.name for x in Tag.objects.all()],
'error_message': error.message
}
return render(request, "request/create_request.html", context)
def test_save(self):
request = Request(ip='1.2.3.4')
request.save()
def test_hostname_invalid(self, *mocks):
request = Request(ip='1.2.3.4')
self.assertEqual(request.hostname, request.ip)
def test_hostname(self, *mocks):
request = Request(ip='1.2.3.4')
self.assertEqual(request.hostname, 'foo.net')
