#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Tests for google.apphosting.tools.devappserver2.wsgi_request_info."""
import re
import unittest
import wsgiref.util
from google.appengine.tools.devappserver2 import wsgi_request_info
class TestWSGIRequestInfo(unittest.TestCase):
"""Tests for WSGIRequestInfo."""
def setUp(self):
self.dispatcher = object()
self.request_info = wsgi_request_info.WSGIRequestInfo(self.dispatcher)
def _assert_request_id(self, request_id):
self.assertTrue(re.match('[a-zA-Z]{10}$', request_id),
'invalid request id: %r' % request_id)
def _create_environ(self, scheme, host, path='', query=''):
environ = {'wsgi.url_scheme': scheme,
'HTTP_HOST': host,
'PATH_INFO': path,
'QUERY_STRING': query}
wsgiref.util.setup_testing_defaults(environ)
return environ
def _create_module_configuration(self, module_name, version_id):
class ModuleConfiguration(object):
pass
config = ModuleConfiguration()
config.major_version = version_id
config.module_name = module_name
return config
def test_get_request_url(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertEqual('https://machine:8080/foo?bar=baz',
self.request_info.get_request_url(request_id))
def test_get_request_environ(self):
environ = object()
with self.request_info.request(
environ,
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertIs(environ, self.request_info.get_request_environ(request_id))
def test_get_dispatcher(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertEqual(self.dispatcher,
self.request_info.get_dispatcher())
def test_get_module(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertEqual('default', self.request_info.get_module(request_id))
def test_get_version(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertEqual('1', self.request_info.get_version(request_id))
def test_get_instance_unset(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
self._assert_request_id(request_id)
self.assertIsNone(self.request_info.get_instance(request_id))
def test_get_instance(self):
with self.request_info.request(
self._create_environ('https', 'machine:8080',
'/foo', 'bar=baz'),
self._create_module_configuration('default', '1')) as request_id:
instance = object()
self.request_info.set_request_instance(request_id, instance)
self._assert_request_id(request_id)
self.assertEqual(instance, self.request_info.get_instance(request_id))
def test_concurrent_requests(self):
request_id1 = self.request_info.start_request(
self._create_environ('http', 'machine:8081'),
self._create_module_configuration('default', '1'))
request_id2 = self.request_info.start_request(
self._create_environ('http', 'machine:8082'),
self._create_module_configuration('default', '2'))
request_id3 = self.request_info.start_request(
self._create_environ('http', 'machine:8083'),
self._create_module_configuration('other', '1'))
self._assert_request_id(request_id1)
self._assert_request_id(request_id2)
self._assert_request_id(request_id3)
self.assertTrue(request_id1 != request_id2 != request_id3)
self.assertEqual('http://machine:8081/',
self.request_info.get_request_url(request_id1))
self.assertEqual(self.dispatcher,
self.request_info.get_dispatcher())
self.assertEqual('default', self.request_info.get_module(request_id1))
self.assertEqual('1', self.request_info.get_version(request_id1))
self.assertEqual('http://machine:8082/',
self.request_info.get_request_url(request_id2))
self.assertEqual(self.dispatcher,
self.request_info.get_dispatcher())
self.assertEqual('default', self.request_info.get_module(request_id2))
self.assertEqual('2', self.request_info.get_version(request_id2))
self.request_info.end_request(request_id1)
self.request_info.end_request(request_id2)
self.assertEqual('http://machine:8083/',
self.request_info.get_request_url(request_id3))
self.assertEqual(self.dispatcher,
self.request_info.get_dispatcher())
self.assertEqual('other', self.request_info.get_module(request_id3))
self.assertEqual('1', self.request_info.get_version(request_id3))
if __name__ == '__main__':
unittest.main()
from django.shortcuts import render, HttpResponse, redirect
from .models import Account, Admission, Student
from django.db import IntegrityError
from .decorator import allowed_users
from django.contrib.auth.decorators import login_required
import datetime
import secrets, random
import string
import datetime
year_s = datetime.datetime.today().year
YEARS = list(range(year_s, year_s - 6, -1))
def gen():
N = 7
res = ''.join(secrets.choice(string.ascii_uppercase + string.digits) for i in range(N))
res = 'PCMT' + str(datetime.datetime.today().year) + res
return res
@login_required(login_url='college:login')
def studentsRegistration(request):
if request.POST:
# try:
if request.POST.get('email'):
try:
enrollment_no = gen()
add_user = Account()
add_user.email = request.POST.get('email')
request.session['student_email'] = request.POST.get('email')
print(request.session['student_email'])
add_user.enrollment_no = enrollment_no
add_user.set_password(enrollment_no)
add_user.is_student = True
add_user.is_approved = True
add_user.save()
print('hello')
user = Student()
user.semester = request.POST.get('semester')
user.year = str(datetime.datetime.today().year)
user.student_data = add_user
user.enrollment_no = enrollment_no
user.email = request.POST.get('email')
user.contact_no = request.POST.get('contact_no')
user.first_name = request.POST.get('first_name')
user.last_name = request.POST.get('last_name')
user.dob = request.POST.get('dob')
user.gender = request.POST.get('gender')
user.address = request.POST.get('address')
user.city = request.POST.get('city')
user.state = request.POST.get('state')
user.country = request.POST.get('country')
user.fathers_name = request.POST.get('fathers_name')
user.mothers_name = request.POST.get('mothers_name')
user.blood_group = request.POST.get('blood_group')
user.mothers_tongue = request.POST.get('mothers_tongue')
user.fathers_contact_no = request.POST.get('fathers_contact_no')
user.guardian_name = request.POST.get('guardian_name')
user.guardian_contact_no = request.POST.get('guardian_contact_no')
user.relation_with_guardian = request.POST.get('relation_with_guardian')
user.nationality = request.POST.get('nationality')
user.cast = request.POST.get('cast')
user.religion = request.POST.get('religion')
user.physically_challenge = request.POST.get('physically_challenge')
user.department = request.POST.get('department')
user.aadhar_card_no = request.POST.get('aadhar_card_no')
user.save()
user.physically_certificate = request.FILES.get('physically_certificate')
user.cast_certificate = request.FILES.get('cast_certificate')
user.photo = request.FILES.get('photo')
user.aadhar_card = request.FILES.get('aadhar_card')
user.saveQrCode(enrollment_no=enrollment_no)
user.save()
msg = "Saved successfully"
color = 'success'
return render(request, 'registration.html', {'msg': msg, 'color': color})
except:
if Student.objects.filter(email=request.session['student_email']).count():
msg = "Fill Entrance Examination field"
color = 'danger'
print('hello', Student.objects.filter(email=request.session['student_email']).count)
return render(request, 'registration.html', {'msg': msg, 'color': color})
else:
msg = "Try fill all the filed"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
elif request.POST.get('admission_cat'):
try:
user = Student.objects.get(email=request.session['student_email'])
user.admission_cat = request.POST.get('admission_cat')
user.conducted_by = request.POST.get('conducted_by')
user.rank = request.POST.get('rank')
user.roll_no = request.POST.get('roll_no')
user.allotment = request.POST.get('allotment')
user.admit_card = request.FILES.get('admit_card')
user.rank_card = request.FILES.get('rank_card')
user.roll_no = request.POST.get('roll_no')
user.save()
msg = "Saved successfully And Fill Education information 10th"
color = 'success'
return render(request, 'registration.html', {'msg': msg, 'color': color})
except:
msg = "Entrance examination fill all field"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
elif request.POST.get('school_name_10'):
try:
user = Student.objects.get(email=request.session['student_email'])
user.school_name_10 = request.POST.get('school_name_10')
user.board_10 = request.POST.get('board_10')
user.medium_10 = request.POST.get('medium_10')
user.address10 = request.POST.get('address10')
user.city10 = request.POST.get('city10')
user.state10 = request.POST.get('state10')
user.country10 = request.POST.get('country10')
user.passing_year_10 = request.POST.get('passing_year_10')
user.sub1 = request.POST.get('sub1')
user.sub2 = request.POST.get('sub2')
user.sub3 = request.POST.get('sub3')
user.sub4 = request.POST.get('sub4')
user.sub5 = request.POST.get('sub5')
user.aggregate10 = request.POST.get('aggregate10')
user.mark10 = request.FILES.get('mark10')
user.admit10 = request.FILES.get('admit10')
user.certificate10 = request.FILES.get('certificate10')
user.save()
msg = "Saved successfully And Fill 12th or Diploma form"
color = 'success'
return render(request, 'new_enrollment.html', {'msg': msg, 'color': color})
except:
msg = "Fill Education information 10th all field correctly"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
elif request.POST.get('diploma_or_12') == '12th':
try:
user = Student.objects.get(email=request.session['student_email'])
user.school_name_12 = request.POST.get('school_name_12')
user.board_12 = request.POST.get('board_12')
user.medium_12 = request.POST.get('medium_12')
user.address12 = request.POST.get('address12')
user.city12 = request.POST.get('city12')
user.state12 = request.POST.get('state12')
user.country12 = request.POST.get('country12')
user.passing_year_12 = request.POST.get('passing_year_12')
user.english = request.POST.get('english')
user.chemistry = request.POST.get('chemistry')
user.physics = request.POST.get('physics')
user.math = request.POST.get('math')
user.optional = request.POST.get('optional')
user.aggregate12 = request.POST.get('aggregate12')
user.mark12 = request.FILES.get('mark12')
user.admit12 = request.FILES.get('admit12')
user.certificate12 = request.FILES.get('certificate12')
user.save()
msg = "Saved successfully And Fill others form"
color = 'success'
return render(request, 'registration.html', {'msg': msg, 'color': color})
except:
msg = "Fill Education 12th or Diploma"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
elif request.POST.get('diploma_or_12') == 'diploma':
try:
user = Student.objects.get(email=request.session['student_email'])
user.school_name_diploma = request.POST.get('school_name_diploma')
user.board_diploma = request.POST.get('board_diploma')
user.medium_diploma = request.POST.get('medium_diploma')
user.addressDiploma = request.POST.get('addressDiploma')
user.cityDiploma = request.POST.get('cityDiploma')
user.stateDiploma = request.POST.get('stateDiploma')
user.countryDiploma = request.POST.get('countryDiploma')
user.passing_year_Diploma = request.POST.get('passing_year_Diploma')
user.marksDiploma = request.POST.get('marksDiploma')
user.aggregateDiploma = request.POST.get('aggregateDiploma')
user.division = request.POST.get('division')
user.markDiploma = request.FILES.get('markDiploma')
user.certificateDiploma = request.FILES.get('certificateDiploma')
user.save()
msg = "Saved successfully And Fill others form"
color = 'success'
return render(request, 'registration.html', {'msg': msg, 'color': color})
except:
msg = "Fill Education 12th or Diploma"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
elif request.POST.get('loan'):
try:
user = Student.objects.get(email=request.session['student_email'])
user.loan = request.POST.get('loan')
user.gap = request.POST.get('gap')
user.reason = request.POST.get('reason')
user.hostel = request.POST.get('hostel')
user.save()
msg = "Saved successfully"
color = 'success'
return render(request, 'registration.html', {'msg': msg, 'color': color})
except:
msg = "Try fill all fields"
color = 'danger'
return render(request, 'registration.html', {'msg': msg, 'color': color})
return render(request, 'registration.html', )
@login_required(login_url='college:login')
def student_data_view(request):
if request.POST and not request.user.is_student:
if request.POST.get('university_roll') and not request.user.is_student:
university_roll = request.POST.get('university_roll')
User = Student.objects.get(university_roll=university_roll)
return render(request, "student_data_view.html", context={'user': User, 'YEARS': YEARS})
else:
year = request.POST.get('go_year')
semester = request.POST.get('go_semester')
User = Student.objects.filter(semester=semester, year=year)
return render(request, "student_data_view.html", context={'user': User, 'YEARS': YEARS})
elif request.user.is_HOD:
user = {}
return render(request, "student_data_view.html", context={'user': user, 'YEARS': YEARS})
elif request.user.is_admin:
user = {}
return render(request, "student_data_view.html", context={'user': user, 'YEARS': YEARS})
elif request.user.is_student:
user = Student.objects.filter(email=request.session['email'])
return render(request, "student_data_view.html", context={'user': user, 'YEARS': YEARS})
elif request.user.is_BOC:
# user = Student.objects.filter(is_student=True, year=request.user.year, semester=request.user.semester)
user = {}
return render(request, "student_data_view.html", context={'user': user, 'YEARS': YEARS})
return render(request, "student_data_view.html", context={'YEARS': YEARS})
from django.contrib import messages
from django.http import HttpResponse, HttpResponseForbidden, HttpResponseNotFound
from django.shortcuts import redirect
from django.shortcuts import render
from django.urls import reverse
from django.views.decorators.csrf import csrf_exempt
from app import settings
from app.models import Operators, Product_Requests, Product_Request_Items, Products
from app.utils import Utils
from backend.forms.product_request_item_forms import ProductRequestItemCreateForm, ProductRequestItemUpdateForm
# noinspection PyUnusedLocal, PyShadowingBuiltins
def create(request, id):
template_url = 'product-request-items/create.html'
operator = Operators.login_required(request)
if operator is None:
Operators.set_redirect_field_name(request, request.path)
return redirect(reverse("operators_signin"))
else:
auth_permissions = Operators.get_auth_permissions(operator)
if settings.ACCESS_PERMISSION_ORDER_CREATE in auth_permissions.values():
try:
product_request = Product_Requests.objects.get(product_request_id=id)
if request.method == 'POST':
form = ProductRequestItemCreateForm(request.POST)
# noinspection PyArgumentList
if form.is_valid():
model = Product_Request_Items()
model.product_requests_product_request_id = product_request.product_request_id
model.products_product_id = form.cleaned_data['products_product_id']
product = Products.objects.get(product_id=model.products_product_id)
model.product_request_item_product_type = product.product_type
model.product_request_item_product_code = product.product_code
model.product_request_item_product_tag = product.product_tag
model.product_request_item_product_category = product.product_category
model.product_request_item_product_title = product.product_title
model.product_request_item_product_sub_title = product.product_sub_title
model.product_request_item_product_quantity_initial = 0
model.product_request_item_product_quantity_ordered = form.cleaned_data[
'product_request_item_product_quantity_ordered']
model.product_request_item_product_quantity_balance = 0
model.product_request_item_product_quantity_unit = product.product_quantity_unit
model.product_request_item_created_at = Utils.get_current_datetime_utc()
model.product_request_item_created_id = operator.operator_id
model.product_request_item_created_by = operator.operator_name
model.product_request_item_created_department = operator.operator_department
model.product_request_item_created_role = operator.operator_role
model.product_request_item_updated_at = Utils.get_current_datetime_utc()
model.product_request_item_updated_id = operator.operator_id
model.product_request_item_updated_by = operator.operator_name
model.product_request_item_updated_department = operator.operator_department
model.product_request_item_updated_role = operator.operator_role
model.product_request_item_received_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE
model.product_request_item_received_id = ''
model.product_request_item_received_by = ''
model.product_request_item_received_department = ''
model.product_request_item_received_role = ''
model.product_request_item_status = Product_Requests.STATUS_PENDING
# noinspection PyCallByClass,PyTypeChecker
model.save('Created')
Product_Requests.update_grand_total(request, product_request, operator)
messages.success(request, 'Item added successfully.')
return redirect(reverse("product_requests_view", args=[product_request.product_request_id]))
else:
error_string = ' '.join([' '.join(x for x in l) for l in list(form.errors.values())])
messages.error(request, '' + error_string)
return redirect(reverse("product_requests_view", args=[product_request.product_request_id]))
else:
form = ProductRequestItemCreateForm(
initial={
'product_request_id': product_request.product_request_code,
'products_product_id': '',
'product_request_item_product_quantity_ordered': 0,
})
return render(
request, template_url,
{
'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS,
'title': Product_Request_Items.TITLE,
'name': Product_Request_Items.NAME,
'operator': operator,
'auth_permissions': auth_permissions,
'form': form,
}
)
except(TypeError, ValueError, OverflowError,
Product_Requests.DoesNotExist, Product_Request_Items.DoesNotExist):
return HttpResponseNotFound('Not Found', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
# noinspection PyUnusedLocal, PyShadowingBuiltins
def update(request, pk):
template_url = 'product-request-items/update.html'
operator = Operators.login_required(request)
if operator is None:
Operators.set_redirect_field_name(request, request.path)
return redirect(reverse("operators_signin"))
else:
auth_permissions = Operators.get_auth_permissions(operator)
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values():
try:
model = Product_Request_Items.objects.get(product_request_item_id=pk)
product_request = Product_Requests.objects.get(
product_request_id=model.product_requests_product_request_id)
if request.method == 'POST':
form = ProductRequestItemUpdateForm(request.POST)
# noinspection PyArgumentList
if form.is_valid():
model.products_product_id = form.cleaned_data['products_product_id']
product = Products.objects.get(product_id=model.products_product_id)
model.product_request_item_product_type = product.product_type
model.product_request_item_product_code = product.product_code
model.product_request_item_product_tag = product.product_tag
model.product_request_item_product_category = product.product_category
model.product_request_item_product_title = product.product_title
model.product_request_item_product_sub_title = product.product_sub_title
model.product_request_item_product_quantity_initial = 0
model.product_request_item_product_quantity_ordered = form.cleaned_data[
'product_request_item_product_quantity_ordered']
model.product_request_item_product_quantity_balance = 0
model.product_request_item_product_quantity_unit = product.product_quantity_unit
model.product_request_item_updated_at = Utils.get_current_datetime_utc()
model.product_request_item_updated_id = operator.operator_id
model.product_request_item_updated_by = operator.operator_name
model.product_request_item_updated_department = operator.operator_department
model.product_request_item_updated_role = operator.operator_role
model.save()
Product_Requests.update_grand_total(request, product_request, operator)
messages.success(request, 'Item updated successfully.')
return redirect(reverse("product_requests_view", args=[product_request.product_request_id]))
else:
error_string = ' '.join([' '.join(x for x in l) for l in list(form.errors.values())])
messages.error(request, '' + error_string)
return redirect(reverse("product_requests_view", args=[product_request.product_request_id]))
else:
form = ProductRequestItemUpdateForm(
initial={
'product_request_id': product_request.product_request_code,
'products_product_id': model.products_product_id,
'product_request_item_product_quantity_ordered': model.product_request_item_product_quantity_ordered,
}
)
return render(
request, template_url,
{
'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS,
'title': Product_Request_Items.TITLE,
'name': Product_Request_Items.NAME,
'operator': operator,
'auth_permissions': auth_permissions,
'form': form,
'model': model,
}
)
except(
TypeError, ValueError, OverflowError, Product_Requests.DoesNotExist,
Product_Request_Items.DoesNotExist):
return HttpResponseNotFound('Not Found', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
@csrf_exempt
# noinspection PyUnusedLocal
def select_single(request):
if request.is_ajax():
operator = Operators.login_required(request)
if operator is None:
# Operators.set_redirect_field_name(request, request.path)
# return redirect(reverse("operators_signin"))
return HttpResponse('signin', content_type='text/plain')
else:
auth_permissions = Operators.get_auth_permissions(operator)
action = request.POST['action']
id = request.POST['id']
if action != '' and id is not None:
if action == 'delete':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values():
try:
model = Product_Request_Items.objects.get(product_request_item_id=id)
product_request = Product_Requests.objects.get(
product_request_id=model.product_requests_product_request_id)
Product_Request_Items.delete_product_request_item(request, model, operator)
Product_Requests.update_grand_total(request, product_request, operator)
messages.success(request, 'Item removed successfully.')
except(TypeError, ValueError, OverflowError, Product_Request_Items.DoesNotExist):
return HttpResponseBadRequest('Bad Request', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
return HttpResponse('success', content_type='text/plain')
else:
return HttpResponseBadRequest('Bad Request', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
@csrf_exempt
# noinspection PyUnusedLocal
def select_multiple(request):
if request.is_ajax():
operator = Operators.login_required(request)
if operator is None:
# Operators.set_redirect_field_name(request, request.path)
# return redirect(reverse("operators_signin"))
return HttpResponse('signin', content_type='text/plain')
else:
auth_permissions = Operators.get_auth_permissions(operator)
action = request.POST['action']
ids = request.POST['ids']
try:
ids = ids.split(",")
except(TypeError, ValueError, OverflowError):
ids = None
if action != '' and ids is not None:
if action == 'order-item-received':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values():
for id in ids:
try:
model = Product_Request_Items.objects.get(product_request_item_id=id)
if model.product_request_item_status == Product_Request_Items.STATUS_PENDING:
try:
product = Products.objects.get(product_id=model.products_product_id)
model.product_request_item_product_quantity_initial = product.product_quantity_available
product.product_quantity_available = product.product_quantity_available - model.product_request_item_product_quantity_ordered
model.product_request_item_product_quantity_balance = product.product_quantity_available
product.product_updated_at = Utils.get_current_datetime_utc()
product.product_updated_id = operator.operator_id
product.product_updated_by = operator.operator_name
product.product_updated_department = operator.operator_department
product.product_updated_role = operator.operator_role
product.save()
except (Product_Requests.DoesNotExist, Products.DoesNotExist):
print('Product Request does not exist.')
model.product_request_item_received_at = Utils.get_current_datetime_utc()
model.product_request_item_received_id = operator.operator_id
model.product_request_item_received_by = operator.operator_name
model.product_request_item_received_department = operator.operator_department
model.product_request_item_received_role = operator.operator_role
model.product_request_item_status = Product_Request_Items.STATUS_RECEIVED
model.save()
except(TypeError, ValueError, OverflowError, Product_Request_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
if action == 'order-item-pending':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values():
for id in ids:
try:
model = Product_Request_Items.objects.get(product_request_item_id=id)
if model.product_request_item_status == Product_Request_Items.STATUS_RECEIVED:
try:
product = Products.objects.get(product_id=model.products_product_id)
model.product_request_item_product_quantity_initial = 0
product.product_quantity_available = product.product_quantity_available + model.product_request_item_product_quantity_ordered
model.product_request_item_product_quantity_balance = 0
product.product_updated_at = Utils.get_current_datetime_utc()
product.product_updated_id = operator.operator_id
product.product_updated_by = operator.operator_name
product.product_updated_department = operator.operator_department
product.product_updated_role = operator.operator_role
product.save()
except (Product_Requests.DoesNotExist, Products.DoesNotExist):
print('Product Request not exist.')
model.product_request_item_received_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE
model.product_request_item_received_id = ''
model.product_request_item_received_by = ''
model.product_request_item_received_department = ''
model.product_request_item_received_role = ''
model.product_request_item_status = Product_Request_Items.STATUS_PENDING
model.save()
except(TypeError, ValueError, OverflowError, Product_Request_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
return HttpResponse('success', content_type='text/plain')
else:
return HttpResponseBadRequest('Bad Request', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
describe('FakeRequest', function() {
beforeEach(function() {
this.requestTracker = { track: jasmine.createSpy('trackRequest') };
this.stubTracker = { findStub: function() {} };
var parserInstance = this.parserInstance = jasmine.createSpy('parse');
this.paramParser = { findParser: function() { return { parse: parserInstance }; } };
this.fakeGlobal = {
XMLHttpRequest: function() {
this.extraAttribute = 'my cool attribute';
},
DOMParser: window.DOMParser,
ActiveXObject: window.ActiveXObject
};
this.FakeRequest = getJasmineRequireObj().AjaxFakeRequest()(this.fakeGlobal, this.requestTracker, this.stubTracker, this.paramParser);
});
it('extends from the global XMLHttpRequest', function() {
var request = new this.FakeRequest();
expect(request.extraAttribute).toEqual('my cool attribute');
});
it('skips XMLHttpRequest attributes that IE does not want copied', function() {
// use real window here so it will correctly go red on IE if it breaks
var FakeRequest = getJasmineRequireObj().AjaxFakeRequest()(window, this.requestTracker, this.stubTracker, this.paramParser);
var request = new FakeRequest();
expect(request.responseBody).toBeUndefined();
expect(request.responseXML).toBeUndefined();
expect(request.statusText).toBeUndefined();
});
it('tracks the request', function() {
var request = new this.FakeRequest();
expect(this.requestTracker.track).toHaveBeenCalledWith(request);
});
it('has default request headers and override mime type', function() {
var request = new this.FakeRequest();
expect(request.requestHeaders).toEqual({});
expect(request.overriddenMimeType).toBeNull();
});
it('saves request information when opened', function() {
var request = new this.FakeRequest();
request.open('METHOD', 'URL', 'ignore_async', 'USERNAME', 'PASSWORD');
expect(request.method).toEqual('METHOD');
expect(request.url).toEqual('URL');
expect(request.username).toEqual('USERNAME');
expect(request.password).toEqual('PASSWORD');
});
it('saves an override mime type', function() {
var request = new this.FakeRequest();
request.overrideMimeType('application/text; charset: utf-8');
expect(request.overriddenMimeType).toBe('application/text; charset: utf-8');
});
it('saves request headers', function() {
var request = new this.FakeRequest();
request.setRequestHeader('X-Header-1', 'value1');
request.setRequestHeader('X-Header-2', 'value2');
expect(request.requestHeaders).toEqual({
'X-Header-1': 'value1',
'X-Header-2': 'value2'
});
});
it('combines request headers with the same header name', function() {
var request = new this.FakeRequest();
request.setRequestHeader('X-Header', 'value1');
request.setRequestHeader('X-Header', 'value2');
expect(request.requestHeaders['X-Header']).toEqual('value1, value2');
});
it('finds the content-type request header', function() {
var request = new this.FakeRequest();
request.setRequestHeader('ContEnt-tYPe', 'application/text+xml');
expect(request.contentType()).toEqual('application/text+xml');
});
describe('managing readyState', function() {
beforeEach(function() {
this.request = new this.FakeRequest();
this.request.onreadystatechange = jasmine.createSpy('onreadystatechange');
});
it('has an initial ready state of 0 (uninitialized)', function() {
expect(this.request.readyState).toBe(0);
expect(this.request.onreadystatechange).not.toHaveBeenCalled();
});
it('has a ready state of 1 (open) when opened', function() {
this.request.open();
expect(this.request.readyState).toBe(1);
expect(this.request.onreadystatechange).toHaveBeenCalled();
});
it('has a ready state of 0 (uninitialized) when aborted', function() {
this.request.open();
this.request.onreadystatechange.calls.reset();
this.request.abort();
expect(this.request.readyState).toBe(0);
expect(this.request.onreadystatechange).toHaveBeenCalled();
});
it('has a ready state of 2 (sent) when sent', function() {
this.request.open();
this.request.onreadystatechange.calls.reset();
this.request.send();
expect(this.request.readyState).toBe(2);
expect(this.request.onreadystatechange).toHaveBeenCalled();
});
it('has a ready state of 4 (loaded) when timed out', function() {
this.request.open();
this.request.send();
this.request.onreadystatechange.calls.reset();
jasmine.clock().install();
this.request.responseTimeout();
jasmine.clock().uninstall();
expect(this.request.readyState).toBe(4);
expect(this.request.onreadystatechange).toHaveBeenCalledWith('timeout');
});
it('has a ready state of 4 (loaded) when network erroring', function() {
this.request.open();
this.request.send();
this.request.onreadystatechange.calls.reset();
this.request.responseError();
expect(this.request.readyState).toBe(4);
expect(this.request.onreadystatechange).toHaveBeenCalled();
});
it('has a ready state of 4 (loaded) when responding', function() {
this.request.open();
this.request.send();
this.request.onreadystatechange.calls.reset();
this.request.response({});
expect(this.request.readyState).toBe(4);
expect(this.request.onreadystatechange).toHaveBeenCalled();
});
it('throws an error when timing out a request that has completed', function() {
this.request.open();
this.request.send();
this.request.response({});
var request = this.request;
expect(function() {
request.responseTimeout();
}).toThrowError('FakeXMLHttpRequest already completed');
});
it('throws an error when responding to a request that has completed', function() {
this.request.open();
this.request.send();
this.request.response({});
var request = this.request;
expect(function() {
request.response({});
}).toThrowError('FakeXMLHttpRequest already completed');
});
it('throws an error when erroring a request that has completed', function() {
this.request.open();
this.request.send();
this.request.response({});
var request = this.request;
expect(function() {
request.responseError({});
}).toThrowError('FakeXMLHttpRequest already completed');
});
});
describe('triggering progress events', function() {
beforeEach(function() {
this.request = new this.FakeRequest();
spyOn(this.request, 'onloadstart');
spyOn(this.request, 'onprogress');
spyOn(this.request, 'onabort');
spyOn(this.request, 'onerror');
spyOn(this.request, 'onload');
spyOn(this.request, 'ontimeout');
spyOn(this.request, 'onloadend');
var spies = {};
spies.loadstart1 = jasmine.createSpy('loadstart1');
spies.loadstart2 = jasmine.createSpy('loadstart2');
this.request.addEventListener('loadstart', spies.loadstart1);
this.request.addEventListener('loadstart', spies.loadstart2);
spies.progress1 = jasmine.createSpy('progress1');
spies.progress2 = jasmine.createSpy('progress2');
this.request.addEventListener('progress', spies.progress1);
this.request.addEventListener('progress', spies.progress2);
spies.abort1 = jasmine.createSpy('abort1');
spies.abort2 = jasmine.createSpy('abort2');
this.request.addEventListener('abort', spies.abort1);
this.request.addEventListener('abort', spies.abort2);
spies.error1 = jasmine.createSpy('error1');
spies.error2 = jasmine.createSpy('error2');
this.request.addEventListener('error', spies.error1);
this.request.addEventListener('error', spies.error2);
spies.load1 = jasmine.createSpy('load1');
spies.load2 = jasmine.createSpy('load2');
this.request.addEventListener('load', spies.load1);
this.request.addEventListener('load', spies.load2);
spies.timeout1 = jasmine.createSpy('timeout1');
spies.timeout2 = jasmine.createSpy('timeout2');
this.request.addEventListener('timeout', spies.timeout1);
this.request.addEventListener('timeout', spies.timeout2);
spies.loadend1 = jasmine.createSpy('loadend1');
spies.loadend2 = jasmine.createSpy('loadend2');
this.request.addEventListener('loadend', spies.loadend1);
this.request.addEventListener('loadend', spies.loadend2);
this.resetEvents = function() {
var request = this.request;
var events = ['loadstart', 'progress', 'abort', 'error', 'load', 'timeout', 'loadend'];
for (var index in events) {
var event = events[index];
request['on' + event].calls.reset();
spies[event + '1'].calls.reset();
spies[event + '2'].calls.reset();
}
};
jasmine.addMatchers({
toHaveTriggeredEvent: function(util) {
return {
compare: function(actual, expected) {
var direct = actual['on' + expected].calls.any();
var event1 = spies[expected + '1'].calls.any();
var event2 = spies[expected + '2'].calls.any();
var pass = direct && event1 && event2;
var missed = [], triggered = [];
(direct ? triggered : missed).push('direct');
(event1 ? triggered : missed).push(expected + '1');
(event2 ? triggered : missed).push(expected + '2');
return {
pass: pass,
message: pass ?
'Expected XHR not to have triggered ' + expected + ' but ' + triggered.join(', ') + ' triggered' :
'Expected XHR to have triggered ' + expected + ' but ' + missed.join(', ') + " didn't trigger"
};
}
};
}
});
});
it('should not trigger any events to start', function() {
this.request.open();
expect(this.request).not.toHaveTriggeredEvent('loadstart');
expect(this.request).not.toHaveTriggeredEvent('progress');
expect(this.request).not.toHaveTriggeredEvent('abort');
expect(this.request).not.toHaveTriggeredEvent('error');
expect(this.request).not.toHaveTriggeredEvent('load');
expect(this.request).not.toHaveTriggeredEvent('timeout');
expect(this.request).not.toHaveTriggeredEvent('loadend');
});
it('should trigger loadstart when sent', function() {
this.request.open();
this.request.send();
expect(this.request).toHaveTriggeredEvent('loadstart');
expect(this.request).not.toHaveTriggeredEvent('progress');
expect(this.request).not.toHaveTriggeredEvent('abort');
expect(this.request).not.toHaveTriggeredEvent('error');
expect(this.request).not.toHaveTriggeredEvent('load');
expect(this.request).not.toHaveTriggeredEvent('timeout');
expect(this.request).not.toHaveTriggeredEvent('loadend');
});
it('should trigger abort, progress, loadend when aborted', function() {
this.request.open();
this.request.send();
this.resetEvents();
this.request.abort();
expect(this.request).not.toHaveTriggeredEvent('loadstart');
expect(this.request).toHaveTriggeredEvent('progress');
expect(this.request).toHaveTriggeredEvent('abort');
expect(this.request).not.toHaveTriggeredEvent('error');
expect(this.request).not.toHaveTriggeredEvent('load');
expect(this.request).not.toHaveTriggeredEvent('timeout');
expect(this.request).toHaveTriggeredEvent('loadend');
});
it('should trigger error, progress, loadend when network error', function() {
this.request.open();
this.request.send();
this.resetEvents();
this.request.responseError();
expect(this.request).not.toHaveTriggeredEvent('loadstart');
expect(this.request).toHaveTriggeredEvent('progress');
expect(this.request).not.toHaveTriggeredEvent('abort');
expect(this.request).toHaveTriggeredEvent('error');
expect(this.request).not.toHaveTriggeredEvent('load');
expect(this.request).not.toHaveTriggeredEvent('timeout');
expect(this.request).toHaveTriggeredEvent('loadend');
});
it('should trigger timeout, progress, loadend when timing out', function() {
this.request.open();
this.request.send();
this.resetEvents();
jasmine.clock().install();
this.request.responseTimeout();
jasmine.clock().uninstall();
expect(this.request).not.toHaveTriggeredEvent('loadstart');
expect(this.request).toHaveTriggeredEvent('progress');
expect(this.request).not.toHaveTriggeredEvent('abort');
expect(this.request).not.toHaveTriggeredEvent('error');
expect(this.request).not.toHaveTriggeredEvent('load');
expect(this.request).toHaveTriggeredEvent('timeout');
expect(this.request).toHaveTriggeredEvent('loadend');
});
it('should trigger load, progress, loadend when responding', function() {
this.request.open();
this.request.send();
this.resetEvents();
this.request.response({ status: 200 });
expect(this.request).not.toHaveTriggeredEvent('loadstart');
expect(this.request).toHaveTriggeredEvent('progress');
expect(this.request).not.toHaveTriggeredEvent('abort');
expect(this.request).not.toHaveTriggeredEvent('error');
expect(this.request).toHaveTriggeredEvent('load');
expect(this.request).not.toHaveTriggeredEvent('timeout');
expect(this.request).toHaveTriggeredEvent('loadend');
});
});
it('ticks the jasmine clock on timeout', function() {
var clock = { tick: jasmine.createSpy('tick') };
spyOn(jasmine, 'clock').and.returnValue(clock);
var request = new this.FakeRequest();
request.open();
request.send();
request.responseTimeout();
expect(clock.tick).toHaveBeenCalledWith(30000);
});
it('has an initial status of null', function() {
var request = new this.FakeRequest();
expect(request.status).toBeNull();
});
it('has an aborted status', function() {
var request = new this.FakeRequest();
request.abort();
expect(request.status).toBe(0);
expect(request.statusText).toBe('abort');
});
it('has a status from the response', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200 });
expect(request.status).toBe(200);
expect(request.statusText).toBe('');
});
it('has a statusText from the response', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, statusText: 'OK' });
expect(request.status).toBe(200);
expect(request.statusText).toBe('OK');
});
it('saves off any data sent to the server', function() {
var request = new this.FakeRequest();
request.open();
request.send('foo=bar&baz=quux');
expect(request.params).toBe('foo=bar&baz=quux');
});
it('parses data sent to the server', function() {
var request = new this.FakeRequest();
request.open();
request.send('foo=bar&baz=quux');
this.parserInstance.and.returnValue('parsed');
expect(request.data()).toBe('parsed');
});
it('skips parsing if no data was sent', function() {
var request = new this.FakeRequest();
request.open();
request.send();
expect(request.data()).toEqual({});
expect(this.parserInstance).not.toHaveBeenCalled();
});
it('saves responseText', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, responseText: 'foobar' });
expect(request.responseText).toBe('foobar');
});
it('defaults responseText if none is given', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200 });
expect(request.responseText).toBe('');
});
it('retrieves individual response headers', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({
status: 200,
responseHeaders: {
'X-Header': 'foo'
}
});
expect(request.getResponseHeader('X-Header')).toBe('foo');
});
it('retrieves individual response headers case-insensitively', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({
status: 200,
responseHeaders: {
'X-Header': 'foo'
}
});
expect(request.getResponseHeader('x-header')).toBe('foo');
});
it('retrieves a combined response header', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({
status: 200,
responseHeaders: [
{ name: 'X-Header', value: 'foo' },
{ name: 'X-Header', value: 'bar' }
]
});
expect(request.getResponseHeader('x-header')).toBe('foo, bar');
});
it("doesn't pollute the response headers of other XHRs", function() {
var request1 = new this.FakeRequest();
request1.open();
request1.send();
var request2 = new this.FakeRequest();
request2.open();
request2.send();
request1.response({ status: 200, responseHeaders: { 'X-Foo': 'bar' } });
request2.response({ status: 200, responseHeaders: { 'X-Baz': 'quux' } });
expect(request1.getAllResponseHeaders()).toBe('X-Foo: bar');
expect(request2.getAllResponseHeaders()).toBe('X-Baz: quux');
});
it('retrieves all response headers', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({
status: 200,
responseHeaders: [
{ name: 'X-Header-1', value: 'foo' },
{ name: 'X-Header-2', value: 'bar' },
{ name: 'X-Header-1', value: 'baz' }
]
});
expect(request.getAllResponseHeaders()).toBe("X-Header-1: foo\r\nX-Header-2: bar\r\nX-Header-1: baz");
});
it('sets the content-type header to the specified contentType when no other headers are supplied', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, contentType: 'text/plain' });
expect(request.getResponseHeader('content-type')).toBe('text/plain');
expect(request.getAllResponseHeaders()).toBe('Content-Type: text/plain');
});
it('sets a default content-type header if no contentType and headers are supplied', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200 });
expect(request.getResponseHeader('content-type')).toBe('application/json');
expect(request.getAllResponseHeaders()).toBe('Content-Type: application/json');
});
it('has no responseXML by default', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200 });
expect(request.responseXML).toBeNull();
});
it('parses a text/xml document into responseXML', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, contentType: 'text/xml', responseText: '<dom><stuff/></dom>' });
if (typeof window.Document !== 'undefined') {
expect(request.responseXML instanceof window.Document).toBe(true);
} else {
// IE 8
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
}
});
it('parses an application/xml document into responseXML', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, contentType: 'application/xml', responseText: '<dom><stuff/></dom>' });
if (typeof window.Document !== 'undefined') {
expect(request.responseXML instanceof window.Document).toBe(true);
} else {
// IE 8
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
}
});
it('parses a custom blah+xml document into responseXML', function() {
var request = new this.FakeRequest();
request.open();
request.send();
request.response({ status: 200, contentType: 'application/text+xml', responseText: '<dom><stuff/></dom>' });
if (typeof window.Document !== 'undefined') {
expect(request.responseXML instanceof window.Document).toBe(true);
} else {
// IE 8
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
}
});
});
/*
* Copyright (C) 2011 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @constructor
* @extends {WebInspector.Object}
*/
WebInspector.NetworkManager = function()
{
WebInspector.Object.call(this);
this._dispatcher = new WebInspector.NetworkDispatcher(this);
if (WebInspector.settings.cacheDisabled.get())
NetworkAgent.setCacheDisabled(true);
NetworkAgent.enable();
WebInspector.settings.cacheDisabled.addChangeListener(this._cacheDisabledSettingChanged, this);
if (WebInspector.settings.userAgent.get())
this._userAgentSettingChanged();
WebInspector.settings.userAgent.addChangeListener(this._userAgentSettingChanged, this);
}
WebInspector.NetworkManager.EventTypes = {
ResourceTrackingEnabled: "ResourceTrackingEnabled",
ResourceTrackingDisabled: "ResourceTrackingDisabled",
RequestStarted: "RequestStarted",
RequestUpdated: "RequestUpdated",
RequestFinished: "RequestFinished",
RequestUpdateDropped: "RequestUpdateDropped"
}
WebInspector.NetworkManager._MIMETypes = {
"text/html": {"document": true},
"text/xml": {"document": true},
"text/plain": {"document": true},
"application/xhtml+xml": {"document": true},
"text/css": {"stylesheet": true},
"text/xsl": {"stylesheet": true},
"image/jpeg": {"image": true},
"image/png": {"image": true},
"image/gif": {"image": true},
"image/bmp": {"image": true},
"image/svg+xml": {"image": true},
"image/vnd.microsoft.icon": {"image": true},
"image/webp": {"image": true},
"image/x-icon": {"image": true},
"image/x-xbitmap": {"image": true},
"font/ttf": {"font": true},
"font/opentype": {"font": true},
"font/woff": {"font": true},
"application/x-font-type1": {"font": true},
"application/x-font-ttf": {"font": true},
"application/x-font-woff": {"font": true},
"application/x-truetype-font": {"font": true},
"text/javascript": {"script": true},
"text/ecmascript": {"script": true},
"application/javascript": {"script": true},
"application/ecmascript": {"script": true},
"application/x-javascript": {"script": true},
"application/json": {"script": true},
"text/javascript1.1": {"script": true},
"text/javascript1.2": {"script": true},
"text/javascript1.3": {"script": true},
"text/jscript": {"script": true},
"text/livescript": {"script": true},
}
WebInspector.NetworkManager.prototype = {
enableResourceTracking: function()
{
function callback(error)
{
this.dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.ResourceTrackingEnabled);
}
NetworkAgent.enable(callback.bind(this));
},
disableResourceTracking: function()
{
function callback(error)
{
this.dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.ResourceTrackingDisabled);
}
NetworkAgent.disable(callback.bind(this));
},
/**
* @param {string} url
* @return {WebInspector.NetworkRequest}
*/
inflightRequestForURL: function(url)
{
return this._dispatcher._inflightRequestsByURL[url];
},
/**
* @param {WebInspector.Event} event
*/
_cacheDisabledSettingChanged: function(event)
{
var enabled = /** @type {boolean} */ event.data;
NetworkAgent.setCacheDisabled(enabled);
},
_userAgentSettingChanged: function()
{
NetworkAgent.setUserAgentOverride(WebInspector.settings.userAgent.get());
}
}
WebInspector.NetworkManager.prototype.__proto__ = WebInspector.Object.prototype;
/**
* @constructor
* @implements {NetworkAgent.Dispatcher}
*/
WebInspector.NetworkDispatcher = function(manager)
{
this._manager = manager;
this._inflightRequestsById = {};
this._inflightRequestsByURL = {};
InspectorBackend.registerNetworkDispatcher(this);
}
WebInspector.NetworkDispatcher.prototype = {
/**
* @param {NetworkAgent.Headers} headersMap
* @return {Array.<Object>}
*/
_headersMapToHeadersArray: function(headersMap)
{
var result = [];
for (var name in headersMap) {
var values = headersMap[name].split("\n");
for (var i = 0; i < values.length; ++i)
result.push({ name: name, value: values[i] });
}
return result;
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
* @param {NetworkAgent.Request} request
*/
_updateNetworkRequestWithRequest: function(networkRequest, request)
{
networkRequest.requestMethod = request.method;
networkRequest.requestHeaders = this._headersMapToHeadersArray(request.headers);
networkRequest.requestFormData = request.postData;
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
* @param {NetworkAgent.Response=} response
*/
_updateNetworkRequestWithResponse: function(networkRequest, response)
{
if (!response)
return;
if (response.url && networkRequest.url !== response.url)
networkRequest.url = response.url;
networkRequest.mimeType = response.mimeType;
networkRequest.statusCode = response.status;
networkRequest.statusText = response.statusText;
networkRequest.responseHeaders = this._headersMapToHeadersArray(response.headers);
if (response.headersText)
networkRequest.responseHeadersText = response.headersText;
if (response.requestHeaders)
networkRequest.requestHeaders = this._headersMapToHeadersArray(response.requestHeaders);
if (response.requestHeadersText)
networkRequest.requestHeadersText = response.requestHeadersText;
networkRequest.connectionReused = response.connectionReused;
networkRequest.connectionId = response.connectionId;
if (response.fromDiskCache)
networkRequest.cached = true;
else
networkRequest.timing = response.timing;
if (!this._mimeTypeIsConsistentWithType(networkRequest)) {
WebInspector.console.addMessage(WebInspector.ConsoleMessage.create(WebInspector.ConsoleMessage.MessageSource.Network,
WebInspector.ConsoleMessage.MessageLevel.Warning,
WebInspector.UIString("Resource interpreted as %s but transferred with MIME type %s: \"%s\".", networkRequest.type.title(), networkRequest.mimeType, networkRequest.url),
WebInspector.ConsoleMessage.MessageType.Log,
"",
0,
1,
[],
null,
networkRequest));
}
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
* @return {boolean}
*/
_mimeTypeIsConsistentWithType: function(networkRequest)
{
// If status is an error, content is likely to be of an inconsistent type,
// as it's going to be an error message. We do not want to emit a warning
// for this, though, as this will already be reported as resource loading failure.
// Also, if a URL like http://localhost/wiki/load.php?debug=true&lang=en produces text/css and gets reloaded,
// it is 304 Not Modified and its guessed mime-type is text/php, which is wrong.
// Don't check for mime-types in 304-resources.
if (networkRequest.hasErrorStatusCode() || networkRequest.statusCode === 304)
return true;
if (typeof networkRequest.type === "undefined"
|| networkRequest.type === WebInspector.resourceTypes.Other
|| networkRequest.type === WebInspector.resourceTypes.XHR
|| networkRequest.type === WebInspector.resourceTypes.WebSocket)
return true;
if (!networkRequest.mimeType)
return true; // Might be not known for cached resources with null responses.
if (networkRequest.mimeType in WebInspector.NetworkManager._MIMETypes)
return networkRequest.type.name() in WebInspector.NetworkManager._MIMETypes[networkRequest.mimeType];
return false;
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
* @param {?NetworkAgent.CachedResource} cachedResource
*/
_updateNetworkRequestWithCachedResource: function(networkRequest, cachedResource)
{
networkRequest.type = WebInspector.resourceTypes[cachedResource.type];
networkRequest.resourceSize = cachedResource.bodySize;
this._updateNetworkRequestWithResponse(networkRequest, cachedResource.response);
},
/**
* @param {NetworkAgent.Response} response
* @return {boolean}
*/
_isNull: function(response)
{
if (!response)
return true;
return !response.status && !response.mimeType && (!response.headers || !Object.keys(response.headers).length);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.FrameId} frameId
* @param {NetworkAgent.LoaderId} loaderId
* @param {string} documentURL
* @param {NetworkAgent.Request} request
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.Initiator} initiator
* @param {NetworkAgent.Response=} redirectResponse
*/
requestWillBeSent: function(requestId, frameId, loaderId, documentURL, request, time, initiator, redirectResponse)
{
var networkRequest = this._inflightRequestsById[requestId];
if (networkRequest) {
// FIXME: move this check to the backend.
if (!redirectResponse)
return;
this.responseReceived(requestId, frameId, loaderId, time, "Other", redirectResponse);
networkRequest = this._appendRedirect(requestId, time, request.url);
} else
networkRequest = this._createNetworkRequest(requestId, frameId, loaderId, request.url, documentURL, initiator);
networkRequest.hasNetworkData = true;
this._updateNetworkRequestWithRequest(networkRequest, request);
networkRequest.startTime = time;
this._startNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
*/
requestServedFromCache: function(requestId)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.cached = true;
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.FrameId} frameId
* @param {NetworkAgent.LoaderId} loaderId
* @param {NetworkAgent.Timestamp} time
* @param {PageAgent.ResourceType} resourceType
* @param {NetworkAgent.Response} response
*/
responseReceived: function(requestId, frameId, loaderId, time, resourceType, response)
{
// FIXME: move this check to the backend.
if (this._isNull(response))
return;
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest) {
// We missed the requestWillBeSent.
var eventData = {};
eventData.url = response.url;
eventData.frameId = frameId;
eventData.loaderId = loaderId;
eventData.resourceType = resourceType;
eventData.mimeType = response.mimeType;
this._manager.dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.RequestUpdateDropped, eventData);
return;
}
networkRequest.responseReceivedTime = time;
networkRequest.type = WebInspector.resourceTypes[resourceType];
this._updateNetworkRequestWithResponse(networkRequest, response);
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {number} dataLength
* @param {number} encodedDataLength
*/
dataReceived: function(requestId, time, dataLength, encodedDataLength)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.resourceSize += dataLength;
if (encodedDataLength != -1)
networkRequest.increaseTransferSize(encodedDataLength);
networkRequest.endTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} finishTime
*/
loadingFinished: function(requestId, finishTime)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
this._finishNetworkRequest(networkRequest, finishTime);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {string} localizedDescription
* @param {boolean=} canceled
*/
loadingFailed: function(requestId, time, localizedDescription, canceled)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.failed = true;
networkRequest.canceled = canceled;
networkRequest.localizedFailDescription = localizedDescription;
this._finishNetworkRequest(networkRequest, time);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.FrameId} frameId
* @param {NetworkAgent.LoaderId} loaderId
* @param {string} documentURL
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.Initiator} initiator
* @param {NetworkAgent.CachedResource} cachedResource
*/
requestServedFromMemoryCache: function(requestId, frameId, loaderId, documentURL, time, initiator, cachedResource)
{
var networkRequest = this._createNetworkRequest(requestId, frameId, loaderId, cachedResource.url, documentURL, initiator);
this._updateNetworkRequestWithCachedResource(networkRequest, cachedResource);
networkRequest.cached = true;
networkRequest.requestMethod = "GET";
this._startNetworkRequest(networkRequest);
networkRequest.startTime = networkRequest.responseReceivedTime = time;
this._finishNetworkRequest(networkRequest, time);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {string} requestURL
*/
webSocketCreated: function(requestId, requestURL)
{
var networkRequest = new WebInspector.NetworkRequest(requestId, requestURL, "", "", "");
networkRequest.type = WebInspector.resourceTypes.WebSocket;
this._startNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.WebSocketRequest} request
*/
webSocketWillSendHandshakeRequest: function(requestId, time, request)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.requestMethod = "GET";
networkRequest.requestHeaders = this._headersMapToHeadersArray(request.headers);
networkRequest.webSocketRequestKey3 = request.requestKey3;
networkRequest.startTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.WebSocketResponse} response
*/
webSocketHandshakeResponseReceived: function(requestId, time, response)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.statusCode = response.status;
networkRequest.statusText = response.statusText;
networkRequest.responseHeaders = this._headersMapToHeadersArray(response.headers);
networkRequest.webSocketChallengeResponse = response.challengeResponse;
networkRequest.responseReceivedTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.WebSocketFrame} response
*/
webSocketFrameReceived: function(requestId, time, response)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.addFrame(response, time);
networkRequest.responseReceivedTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {NetworkAgent.WebSocketFrame} response
*/
webSocketFrameSent: function(requestId, time, response)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.addFrame(response, time, true);
networkRequest.responseReceivedTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {string} errorMessage
*/
webSocketFrameError: function(requestId, time, errorMessage)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
networkRequest.addFrameError(errorMessage, time);
networkRequest.responseReceivedTime = time;
this._updateNetworkRequest(networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
*/
webSocketClosed: function(requestId, time)
{
var networkRequest = this._inflightRequestsById[requestId];
if (!networkRequest)
return;
this._finishNetworkRequest(networkRequest, time);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {NetworkAgent.Timestamp} time
* @param {string} redirectURL
* @return {WebInspector.NetworkRequest}
*/
_appendRedirect: function(requestId, time, redirectURL)
{
var originalNetworkRequest = this._inflightRequestsById[requestId];
var previousRedirects = originalNetworkRequest.redirects || [];
originalNetworkRequest.requestId = "redirected:" + requestId + "." + previousRedirects.length;
delete originalNetworkRequest.redirects;
if (previousRedirects.length > 0)
originalNetworkRequest.redirectSource = previousRedirects[previousRedirects.length - 1];
this._finishNetworkRequest(originalNetworkRequest, time);
var newNetworkRequest = this._createNetworkRequest(requestId, originalNetworkRequest.frameId, originalNetworkRequest.loaderId,
redirectURL, originalNetworkRequest.documentURL, originalNetworkRequest.initiator);
newNetworkRequest.redirects = previousRedirects.concat(originalNetworkRequest);
return newNetworkRequest;
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
*/
_startNetworkRequest: function(networkRequest)
{
this._inflightRequestsById[networkRequest.requestId] = networkRequest;
this._inflightRequestsByURL[networkRequest.url] = networkRequest;
this._dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.RequestStarted, networkRequest);
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
*/
_updateNetworkRequest: function(networkRequest)
{
this._dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.RequestUpdated, networkRequest);
},
/**
* @param {WebInspector.NetworkRequest} networkRequest
* @param {NetworkAgent.Timestamp} finishTime
*/
_finishNetworkRequest: function(networkRequest, finishTime)
{
networkRequest.endTime = finishTime;
networkRequest.finished = true;
this._dispatchEventToListeners(WebInspector.NetworkManager.EventTypes.RequestFinished, networkRequest);
delete this._inflightRequestsById[networkRequest.requestId];
delete this._inflightRequestsByURL[networkRequest.url];
},
/**
* @param {string} eventType
* @param {WebInspector.NetworkRequest} networkRequest
*/
_dispatchEventToListeners: function(eventType, networkRequest)
{
this._manager.dispatchEventToListeners(eventType, networkRequest);
},
/**
* @param {NetworkAgent.RequestId} requestId
* @param {string} frameId
* @param {NetworkAgent.LoaderId} loaderId
* @param {string} url
* @param {string} documentURL
* @param {NetworkAgent.Initiator} initiator
*/
_createNetworkRequest: function(requestId, frameId, loaderId, url, documentURL, initiator)
{
var networkRequest = new WebInspector.NetworkRequest(requestId, url, documentURL, frameId, loaderId);
networkRequest.initiator = initiator;
return networkRequest;
}
}
/**
* @type {?WebInspector.NetworkManager}
*/
WebInspector.networkManager = null;
describe("Ext.data.soap.Proxy", function() {
var proxy;
function makeProxy(config) {
proxy = new Ext.data.soap.Proxy(Ext.apply({
model: 'spec.Foo',
type: 'soap',
url: '/soapUrl',
api: {
create: 'Create',
read: 'Read',
update: 'Update',
destroy: 'Destroy'
},
soapAction: {
create: 'CreateAction',
read: 'ReadAction',
update: 'UpdateAction',
destroy: 'DestroyAction'
},
operationParam: 'operation',
targetNamespace: 'tns'
}, config || {}));
}
beforeEach(function() {
Ext.ClassManager.enableNamespaceParseCache = false;
Ext.define('spec.Foo', {
extend: 'Ext.data.Model',
fields: [
{ name: 'id', type: 'int' },
{ name: 'bar', type: 'string' }
]
});
});
afterEach(function(){
Ext.ClassManager.enableNamespaceParseCache = true;
Ext.ModelManager.types = {};
Ext.undefine('spec.Foo');
});
describe("construction", function() {
beforeEach(function() {
makeProxy();
});
it("should create a soap reader", function() {
expect(proxy.reader instanceof Ext.data.soap.Reader).toBe(true);
});
});
describe("doRequest", function() {
var operation, callback, createdCallback, scope, request;
function makeRequest(action, proxyConfig, requestParams) {
makeProxy(proxyConfig);
callback = function() {};
createdCallback = function() {};
scope = {};
spyOn(Ext.Ajax, 'request');
spyOn(proxy, 'createRequestCallback').andReturn(createdCallback);
operation = new Ext.data.Operation({ action: action });
if (action !== 'read') {
operation.records = [
new spec.Foo({id: 1, bar: 'abc'}),
new spec.Foo({id: 2, bar: 'xyz'})
]
}
if (requestParams) {
operation.params = requestParams;
}
request = proxy.doRequest(operation, callback, scope);
}
describe("read operation", function() {
it("should construct a request object", function() {
makeRequest('read');
expect(request instanceof Ext.data.Request).toBe(true);
});
it("should pass the request object to Ext.Ajax.request", function() {
makeRequest('read');
expect(Ext.Ajax.request).toHaveBeenCalledWith(request);
});
it("should set the url in the request object and append the operationParam to the url", function() {
makeRequest('read');
expect(request.url).toBe('/soapUrl?operation=Read');
});
it("should do an HTTP POST", function() {
makeRequest('read');
expect(request.method).toBe('POST');
});
it("should set the action in the request object", function() {
makeRequest('read');
expect(request.action).toBe('read');
});
it("should not set request parameters", function() {
makeRequest('read');
expect(request.params).toBeUndefined();
});
it("should set the SOAPAction header in the request", function() {
makeRequest('read');
expect(request.headers.SOAPAction).toBe('ReadAction');
});
it("should allow the addition of extra request headers", function() {
makeRequest('read', {
headers: {
wibble: 'wobble'
}
});
expect(request.headers.SOAPAction).toBe('ReadAction');
expect(request.headers.wibble).toBe('wobble');
});
it("should create a request callback request object", function() {
makeRequest('read');
expect(proxy.createRequestCallback).toHaveBeenCalledWith(request, operation, callback, scope);
});
it("should set the request callback in the request object", function() {
makeRequest('read');
expect(request.callback).toBe(createdCallback);
});
it("should encode the parameters into a soap envelope", function() {
makeRequest('read', null, {
foo: 42,
bar: 'abc'
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<Read xmlns="tns">',
'<foo>42</foo>',
'<bar>abc</bar>',
'</Read>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should have a soap envelope with empty operation element if there are no paremeters", function() {
makeRequest('read');
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<Read xmlns="tns">',
'</Read>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should merge extraParams into params before creating the soap envelope", function() {
makeRequest('read', {
extraParams: {
baz: 9000
}
}, {
foo: 42,
bar: 'abc'
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<Read xmlns="tns">',
'<foo>42</foo>',
'<bar>abc</bar>',
'<baz>9000</baz>',
'</Read>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should give params precedence over extraParams if there is a conflict", function() {
makeRequest('read', {
extraParams: {
baz: 9000,
bar: 'xyz'
}
}, {
foo: 42,
bar: 'abc'
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<Read xmlns="tns">',
'<foo>42</foo>',
'<bar>abc</bar>',
'<baz>9000</baz>',
'</Read>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should allow configuration of a custom envelope template", function() {
makeRequest('read', {
envelopeTpl: [
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" ',
'xmlns:xsd= "http://www.w3.org/2001/XMLSchema">',
'{[values.bodyTpl.apply(values)]}',
'</soap:Envelope>'
]
}, {
foo: 42
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" ',
'xmlns:xsd= "http://www.w3.org/2001/XMLSchema">',
'<soap:Body>',
'<Read xmlns="tns">',
'<foo>42</foo>',
'</Read>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should allow configuration of a custom body template", function() {
makeRequest('read', {
readBodyTpl: [
'<soap:Body>',
'<RequestContainer>',
'<{operation} xmlns="{targetNamespace}">',
'<tpl foreach="params">',
'<{$}>{.}</{$}>',
'</tpl>',
'</{operation}>',
'</RequestContainer>',
'</soap:Body>'
]
}, {
foo: 42
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<RequestContainer>',
'<Read xmlns="tns">',
'<foo>42</foo>',
'</Read>',
'</RequestContainer>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
});
describe("create operation", function() {
it("should construct a request object", function() {
makeRequest('create');
expect(request instanceof Ext.data.Request).toBe(true);
});
it("should pass the request object to Ext.Ajax.request", function() {
makeRequest('create');
expect(Ext.Ajax.request).toHaveBeenCalledWith(request);
});
it("should set the url in the request object and append the operationParam to the url", function() {
makeRequest('create');
expect(request.url).toBe('/soapUrl?operation=Create');
});
it("should do an HTTP POST", function() {
makeRequest('create');
expect(request.method).toBe('POST');
});
it("should set the action in the request object", function() {
makeRequest('create');
expect(request.action).toBe('create');
});
it("should not set request parameters", function() {
makeRequest('create');
expect(request.params).toBeUndefined();
});
it("should set the SOAPAction header in the request", function() {
makeRequest('create');
expect(request.headers.SOAPAction).toBe('CreateAction');
});
it("should allow the addition of extra request headers", function() {
makeRequest('create', {
headers: {
wibble: 'wobble'
}
});
expect(request.headers.SOAPAction).toBe('CreateAction');
expect(request.headers.wibble).toBe('wobble');
});
it("should create a request callback request object", function() {
makeRequest('create');
expect(proxy.createRequestCallback).toHaveBeenCalledWith(request, operation, callback, scope);
});
it("should set the request callback in the request object", function() {
makeRequest('create');
expect(request.callback).toBe(createdCallback);
});
it("should encode the records into a soap envelope", function() {
makeRequest('create');
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<Create xmlns="tns">',
'<Foo>',
'<id>1</id>',
'<bar>abc</bar>',
'</Foo>',
'<Foo>',
'<id>2</id>',
'<bar>xyz</bar>',
'</Foo>',
'</Create>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should allow configuration of a custom envelope template", function() {
makeRequest('create', {
envelopeTpl: [
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" ',
'xmlns:xsd= "http://www.w3.org/2001/XMLSchema">',
'{[values.bodyTpl.apply(values)]}',
'</soap:Envelope>'
]
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" ',
'xmlns:xsd= "http://www.w3.org/2001/XMLSchema">',
'<soap:Body>',
'<Create xmlns="tns">',
'<Foo>',
'<id>1</id>',
'<bar>abc</bar>',
'</Foo>',
'<Foo>',
'<id>2</id>',
'<bar>xyz</bar>',
'</Foo>',
'</Create>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
it("should allow configuration of a custom body template", function() {
makeRequest('create', {
createBodyTpl: [
'<soap:Body>',
'<RequestContainer>',
'<{operation} xmlns="{targetNamespace}">',
'<tpl for="records">',
'{% var recordName=values.modelName.split(".").pop(); %}',
'<{[recordName]}>',
'<tpl for="fields">',
'<{name}>{[parent.get(values.name)]}</{name}>',
'</tpl>',
'</{[recordName]}>',
'</tpl>',
'</{operation}>',
'</RequestContainer>',
'</soap:Body>'
]
});
expect(request.xmlData).toBe([
'<?xml version="1.0" encoding="utf-8" ?>',
'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">',
'<soap:Body>',
'<RequestContainer>',
'<Create xmlns="tns">',
'<Foo>',
'<id>1</id>',
'<bar>abc</bar>',
'</Foo>',
'<Foo>',
'<id>2</id>',
'<bar>xyz</bar>',
'</Foo>',
'</Create>',
'</RequestContainer>',
'</soap:Body>',
'</soap:Envelope>'
].join(''));
});
});
describe("update operation", function() {
it("should construct a request object", function() {
makeRequest('update');
expect(request instanceof Ext.data.Request).toBe(true);
});
it("should pass the request object to Ext.Ajax.request", function() {
makeRequest('update');
expect(Ext.Ajax.request).toHaveBeenCalledWith(request);
});
it("should set the url in the request object and append the operationParam to the url", function() {
makeRequest('update');
expect(request.url).toBe('/soapUrl?operation=Update');
});
it("should do an HTTP POST", function() {
makeRequest('update');
expect(request.method).toBe('POST');
});
it("should set the action in the request object", function() {
makeRequest('update');
expect(request.action).toBe('update');
});
it("should not set request parameters", function() {
makeRequest('update');
expect(request.params).toBeUndefined();
});
it("should set the SOAPAction header in the request", function() {
makeRequest('update');
expect(request.headers.SOAPAction).toBe('UpdateAction');
});
it("should allow the addition of extra request headers", function() {
makeRequest('update', {
headers: {
wibble: 'wobble'
}
});
