def test_validation_with_no_data(self): """ Validation should still function when no data dictionary is provided. """ uploaded_file = BytesIO(six.b('stuff')) uploaded_file.name = 'stuff.txt' uploaded_file.size = len(uploaded_file.getvalue()) serializer = UploadedFileSerializer(files={'file': uploaded_file}) self.assertFalse(serializer.is_valid())
def test_create(self): now = datetime.datetime.now() file = BytesIO(six.b("stuff")) file.name = "stuff.txt" file.size = len(file.getvalue()) serializer = UploadedFileSerializer(data={"created": now}, files={"file": file}) uploaded_file = UploadedFile(file=file, created=now) self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.object.created, uploaded_file.created) self.assertEqual(serializer.object.file, uploaded_file.file) self.assertFalse(serializer.object is uploaded_file)
def test_remove_with_empty_string(self): """ Passing empty string as data should cause file to be removed Test for: https://github.com/tomchristie/django-rest-framework/issues/937 """ now = datetime.datetime.now() file = BytesIO(six.b('stuff')) file.name = 'stuff.txt' file.size = len(file.getvalue()) uploaded_file = UploadedFile(file=file, created=now) serializer = UploadedFileSerializer(instance=uploaded_file, data={'created': now, 'file': ''}) self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.object.created, uploaded_file.created) self.assertIsNone(serializer.object.file)
def test_interview_deserialization(self): create_uploaded_file(self.user) json = b'{"id": 1, ' \ b' "start": "2015-05-04T12:20:34.000343+0000", ' \ b' "end": "2015-05-04T12:21:34.000343+0000", ' \ b' "status": "OPEN", ' \ b' "job_position": 1,' \ b' "candidate": {"id": 1, "name": "giuseppe", "email": "*****@*****.**", "surname": "pes", "cv": 2},' \ b' "overall_score": 0,'\ b' "catalogue": 1}' stream = BytesIO(json) data = JSONParser().parse(stream) serializer = InterviewSerializer(data=data) print(serializer) self.assertTrue(serializer.is_valid())
def _load_stream(self): """ Return the content body of the request, as a stream. """ try: content_length = int(self.META.get('CONTENT_LENGTH', self.META.get('HTTP_CONTENT_LENGTH'))) except (ValueError, TypeError): content_length = 0 if content_length == 0: self._stream = None elif hasattr(self._request, 'read'): self._stream = self._request else: self._stream = BytesIO(self.raw_post_data)
def test_create_point_location_with_serializer(self): json_data = {"name": "test", "points": [1, 2]} json = JSONRenderer().render(json_data) data = JSONParser().parse(BytesIO(json)) serial = LocationSerializer(data=data) self.assertTrue(serial.is_valid(), serial.errors) serial.save() # point saved then returned as GeoJSON self.assertEquals( Location.objects.get(id=serial.object.id).points, { u'type': u'Point', u'coordinates': [1, 2] }) self.assertEqual(serial.object.name, "test")
def _perform_form_overloading(self): """ If this is a form POST request, then we need to check if the method and content/content_type have been overridden by setting them in hidden form fields or not. """ USE_FORM_OVERLOADING = ( self._METHOD_PARAM or (self._CONTENT_PARAM and self._CONTENTTYPE_PARAM) ) # We only need to use form overloading on form POST requests. if ( not USE_FORM_OVERLOADING or self._request.method != 'POST' or not is_form_media_type(self._content_type) ): return # At this point we're committed to parsing the request as form data. self._data = self._request.POST self._files = self._request.FILES self._full_data = MergeDict(self._data, self._files) # Method overloading - change the method and remove the param from the content. if ( self._METHOD_PARAM and self._METHOD_PARAM in self._data ): self._method = self._data[self._METHOD_PARAM].upper() # Content overloading - modify the content type, and force re-parse. if ( self._CONTENT_PARAM and self._CONTENTTYPE_PARAM and self._CONTENT_PARAM in self._data and self._CONTENTTYPE_PARAM in self._data ): self._content_type = self._data[self._CONTENTTYPE_PARAM] self._stream = BytesIO(self._data[self._CONTENT_PARAM].encode(self.parser_context['encoding'])) self._data, self._files, self._full_data = (Empty, Empty, Empty)
def count(parent_path, **kwargs): logger.info("parent_path: %s, kwargs: %s" % (parent_path, kwargs)) if not parent_path or parent_path == '/': ws_url = settings.ZTREE_WS_BASE_URL + '/count' else: ws_url = settings.ZTREE_WS_BASE_URL + parent_path + '/count' resp = dispatch_request_json(ws_url, data=kwargs) if resp: #resp_py = simplejson.load(StringIO(resp)) resp_py = JSONParser().parse(BytesIO(resp)) # did we get a dict back and has it got a 'count' key if type(resp_py) == type({}) and resp_py.has_key('count'): node_count = int(resp_py['count']) logger.debug("got node count: " % node_count) return (node_count, None) logger.error("could NOT get count") return (0, None)
def testCreateSnippet(self): # 序列化其中一个实例: serializer = SnippetSerializer(self.snippet2) print serializer.data # {'pk': 2, 'title': u'', 'code': u'print "hello, world"\n', 'linenos': False, 'language':u'python', 'style': u'friendly'} # 以上代码已将snippet实例转化为Python基本数据类型, 接下来我们完成序列化: content = JSONRenderer().render(serializer.data) print content # '{"pk": 2, "title": "", "code": "print \\"hello, world\\"\\n", "linenos": false, "language": "python", "style": "friendly"}' # 反序列化也是类似的, 首先将stream转为python基本类型: stream = BytesIO(content) data = JSONParser().parse(stream) # 然后我们将它转化为snippet实例: serializer = SnippetSerializer(data=data) self.assertEqual(serializer.is_valid(), True) # True print serializer.object
def _get_patient_data_from_alternate_facility(query): r = None obj = None msg = None fac = None c_msg = None conditions = None other_conditions = None patient_id = None key = query.strip()[:3].upper() if urls.has_key(key): raw_url = urls[key] url = raw_url + 'detail/' + query try: r = requests.get(url) print r if not r: msg = "Sorry the patient was not found." except (ConnectionError, HTTPError, Timeout), e: print e, "\n\n" msg = "Sorry there was a problem in the connection. Try Again later..." if r: stream = BytesIO(r.text) try: data = JSONParser().parse(stream) except Exception, e: raise e serializer = PatientSerializer(data=data, partial=True) if serializer.is_valid(): obj = serializer.object fac = data['facility_registered_from'] conditions = data['conditions'] msg = "Patient information was found at %s" % str( fac.capitalize()) patient_id = data['id'] other_conditions_url = raw_url + 'conditions/' + str( patient_id) other_conditions, c_msg = _get_other_conditions( other_conditions_url)
def test_interview_deserialization_when_datetime_is_not_iso8610(self): create_uploaded_file(self.user) json = b'{"id": 1, ' \ b' "start": "2014-12-23T11:30", ' \ b' "end": "2014-12-23T12:00", ' \ b' "status": "OPEN", ' \ b' "job_position": 1,' \ b' "candidate": {"id": 1, "name": "giuseppe", "email": "*****@*****.**", "surname": "pes", "cv": 2},' \ b' "catalogue": 1}' stream = BytesIO(json) data = JSONParser().parse(stream) serializer = InterviewSerializer(data=data) self.assertFalse(serializer.is_valid()) self.assertIsNotNone(serializer.errors['start']) self.assertEqual( serializer.errors['start'][0], 'Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm:ss.uuuuuu[+HHMM|-HHMM]' ) self.assertIsNotNone(serializer.errors['end']) self.assertEqual( serializer.errors['end'][0], 'Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm:ss.uuuuuu[+HHMM|-HHMM]' )
def test_question_catalogue_invalid_scope(self): catalogue_json = '{"id": 2, "catalogue_scope": "wrong", "catalogue_name": "cat"}' stream = BytesIO(catalogue_json) data = JSONParser().parse(stream) question_catalogue_serializer = QuestionSerializer(data=data) self.assertFalse(question_catalogue_serializer.is_valid())
def test_question_deserializer_invalid_json(self): question_json = '{"question_catalogue": 1}' stream = BytesIO(question_json) data = JSONParser().parse(stream) serializer = QuestionSerializer(data=data) self.assertFalse(serializer.is_valid())
else: msg = "Sorry the facility with the input search is not available." return (obj, msg, fac, conditions, other_conditions, patient_id) def _get_other_conditions(url): c_msg = None try: r = requests.get(url) if not r: c_msg = "Sorry the patient was not found." except (ConnectionError, HTTPError, Timeout), e: print e, "\n\n" c_msg = "Sorry there was a problem in the connection. Try Again later..." if r: stream = BytesIO(r.text) try: data = JSONParser().parse(stream) except Exception, e: raise e return (data, c_msg) @login_required(login_url='/') def update_patient_data(request, patient_id): patient = get_object_or_404(Patient, pk=patient_id) if request.method == 'POST': update_form = PatientForm(request.POST) if update_form.is_valid(): update_form = PatientForm(request.POST, instance=patient) update_form.save()