def default(self,obj): if isinstance(obj,QuerySet): """ Queryset实例 直接使用Django内置的序列化工具进行序列化 但是如果直接返回serialize('json',obj) 则在simplejson序列化时会被从当成字符串处理 则会多出前后的双引号 因此这里先获得序列化后的对象 然后再用simplejson反序列化一次 得到一个标准的字典(dict)对象 """ return simplejson.loads(serialize('json',obj)) if isinstance(obj,models.Model): """ 如果传入的是单个对象,区别于QuerySet的就是 Django不支持序列化单个对象 因此,首先用单个对象来构造一个只有一个对象的数组 这是就可以看做是QuerySet对象 然后此时再用Django来进行序列化 就如同处理QuerySet一样 但是由于序列化QuerySet会被'[]'所包围 因此使用string[1:-1]来去除 由于序列化QuerySet而带入的'[]' """ jsonstr = simplejson.loads(serialize('json',[obj])[1:-1]) res = jsonstr.get('fields') res["id"]=jsonstr.get("pk") return res if hasattr(obj, 'isoformat'): #处理日期类型 return obj.isoformat() return simplejson.JSONEncoder.default(self,obj)
def clean(self): """Validates message. It must have json format""" try: simplejson.loads(self.message) except ValueError as err: raise ValidationError(_("Message has wrong format: %s") % err)
def fetch_topic(): response = urlfetch.fetch('http://api.ihackernews.com/page', deadline=10) topics = json.loads(response.content) topic_id = str(topics['items'][0]['id']) logging.error(topic_id) response = urlfetch.fetch('http://api.ihackernews.com/post/' + topic_id, deadline=10) topic = json.loads(response.content) topic['graph'] = {} topic['all_comments'] = [] def generate_graph(comments): """Generates an id mapping between comments and their children. This graph is used for javascript layout. { "comment_id": ["child_id", "child_id2"], "comment_id2": ... } """ for comment in comments: topic['all_comments'].append(comment) parent = topic['graph'].setdefault(comment['parentId'], []) parent.append(comment['id']) generate_graph(comment['children']) generate_graph(topic['comments']) return topic
def get(self, action=""): url = self.request.get("url") try: #bit.ly result = urllib.urlopen("http://api.bit.ly/v3/shorten?login=crowy&apiKey=R_57bab6c0fb01da4e1e0a5e22f73c3a4a&format=json&longUrl=%s" % urllib.quote(url)).read() json = simplejson.loads(result) if json['status_code'] == 200: self.response.out.write(json['data']['url']) return else: logging.warn(result) except: logging.warn("Unexpected error.") try: #goo.gl api_url = 'https://www.googleapis.com/urlshortener/v1/url?key=AIzaSyBRoz9ItBIQgHwWbZbmkF45dFiRKub2XzI&userip='+self.request.remote_addr post_data = simplejson.dumps({'longUrl':url}) result = urlfetch.fetch(url=api_url, payload=post_data, method=urlfetch.POST, headers={'Content-Type': 'application/json'}) if result.status_code == 200: result = simplejson.loads(result.content) self.response.out.write(result['id']) return else: logging.warn(result.content) except: logging.warn("Unexpected error.") try:#tinyurl short_url = urllib.urlopen("http://tinyurl.com/api-create.php?url=%s" % urllib.quote(url)) self.response.out.write(short_url.read()) return except: logging.warn("Unexpected error.") self.error(400)
def _lookup_user_info(self, access_token, access_secret): """Lookup User Info. Lookup the user on Yahoo! """ user_info = self._get_default_user_info() # 1) Obtain the user's GUID. response = self.make_request( "http://social.yahooapis.com/v1/me/guid", token=access_token, secret=access_secret, additional_params={"format": "json"}, protected=True) data = json.loads(response.content)["guid"] guid = data["value"] # 2) Inspect the user's profile. response = self.make_request( "http://social.yahooapis.com/v1/user/%s/profile/usercard" % guid, token=access_token, secret=access_secret, additional_params={"format": "json"}, protected=True) data = json.loads(response.content)["profile"] user_info["id"] = guid user_info["username"] = data["nickname"].lower() user_info["name"] = data["nickname"] user_info["picture"] = data["image"]["imageUrl"] return user_info
def retrievelattice(params): ''' ''' name = params['name'] version = params['version'] branch=params['branch'] if params.has_key('description'): description = params['description'] else: description = None if params.has_key('latticetype'): latticetype = params['latticetype'] latticetype = json.loads(latticetype) if not isinstance(latticetype, dict): raise TypeError("Lattice type data parameter format error.") else: latticetype = None if params.has_key('withdata'): withdata = bool(json.loads(params['withdata'].lower())) else: withdata = False if params.has_key('rawdata'): rawdata = bool(json.loads(params['rawdata'].lower())) else: rawdata = False result = latinst.retrievelattice(name, version, branch, description=description, latticetype=latticetype, withdata=withdata, rawdata=rawdata) return result
def test_correct_setup(self): request = MockRequest() request.GET = {"format": "json"} request.method = "GET" # Verify the explicit 'through' relationships has been created correctly resource = api.canonical_resource_for("taggabletag") resp = resource.wrap_view("dispatch_detail")(request, pk=self.taggabletag_1.pk) data = json.loads(resp.content) self.assertEqual(resp.status_code, 200) self.assertEqual(data["tag"], "/v1/tag/1/") self.assertEqual(data["taggable"], "/v1/taggable/1/") resource = api.canonical_resource_for("taggable") resp = resource.wrap_view("dispatch_detail")(request, pk=self.taggable_1.pk) data = json.loads(resp.content) self.assertEqual(resp.status_code, 200) self.assertEqual(data["name"], "exam") resource = api.canonical_resource_for("tag") resp = resource.wrap_view("dispatch_detail")(request, pk=self.tag_1.pk) data = json.loads(resp.content) self.assertEqual(resp.status_code, 200) self.assertEqual(data["name"], "important") # and check whether the extradata is present self.assertEqual(data["extradata"]["name"], u"additional")
def save(self): data = self.cleaned_data name = data['name'] handler = ImageHandlerAlbumCoverTemp() handler.load_by_url(data['thumb']) new_handler = handler.store() new_handler.save_thumbnails() artist = self.artist new = True try: album = Album.objects.get(name=name, artist=artist) new = False except Album.DoesNotExist: album = Album.objects.create( name=name, year=data['year'], artist=artist ) self.is_new = new styles = [] for style in simplejson.loads(data['style']): styles.append(AlbumStyle.objects.get_or_create(name=style)[0]) genres = [] for genre in simplejson.loads(data['genre']): genres.append(AlbumGenre.objects.get_or_create(name=genre)[0]) album.set_metadata_object(self.metadata) album.artist = artist album.style = styles album.genre = genres album.year = data['year'] album.thumb = handler.storage.filename album.save() return album
def updatelattice(params): ''' ''' name=params['name'] version=params['version'] branch=params['branch'] if params.has_key('latticetype'): latticetype = params['latticetype'] latticetype = json.loads(latticetype) if not isinstance(latticetype, dict): raise TypeError("Lattice type data parameter format error.") else: latticetype=None if params.has_key('creator'): creator = params['creator'] else: creator = None if params.has_key('description'): description = params['description'] else: description = None if params.has_key('lattice'): lattice = params['lattice'] lattice = json.loads(lattice) if not isinstance(lattice, dict): raise TypeError("Lattice type data parameter format error.") else: lattice = None result = latinst.updatelattice(name, version, branch, creator=creator, description=description, latticetype=latticetype, lattice=lattice) return {'result': result}
def test_get(self): # Import so that there will be a task object self.dataset.import_data(self.user, self.upload, 0) utils.wait() # Refetch dataset so that attributes will be updated self.dataset = Dataset.objects.get(id=self.dataset.id) response = self.client.get('/api/1.0/dataset/%s/' % self.dataset.slug, **self.auth_headers) self.assertEqual(response.status_code, 200) body = json.loads(response.content) self.assertEqual(body['name'], self.dataset.name) self.assertEqual(body['description'], self.dataset.description) self.assertEqual(body['row_count'], self.dataset.row_count) self.assertEqual(body['sample_data'], self.dataset.sample_data) self.assertEqual(body['column_schema'], self.dataset.column_schema) self.assertEqual(body['creator']['email'], self.dataset.creator.email) task_response = self.client.get('/api/1.0/task/%i/' % self.dataset.current_task.id, **self.auth_headers) self.assertEqual(task_response.status_code, 200) self.assertEqual(body['current_task'], json.loads(task_response.content)) self.assertEqual(len(body['related_uploads']), 0) self.assertEqual(len(body['data_uploads']), 1) self.assertEqual(body['initial_upload'], '/api/1.0/data_upload/%i/' % self.dataset.initial_upload.id)
def test_search_datasets(self): second_dataset = Dataset.objects.create( name='Second dataset', description='contributors', creator=self.dataset.creator) second_dataset.update_full_text() # Should match both response = self.client.get('/api/1.0/dataset/?q=contributors', **self.auth_headers) self.assertEqual(response.status_code, 200) body = json.loads(response.content) self.assertEqual(body['meta']['total_count'], 2) self.assertEqual(len(body['objects']), 2) # Should match only the second dataset response = self.client.get('/api/1.0/dataset/?q=second', **self.auth_headers) self.assertEqual(response.status_code, 200) body = json.loads(response.content) self.assertEqual(body['meta']['total_count'], 1) self.assertEqual(len(body['objects']), 1) self.assertEqual(int(body['objects'][0]['id']), second_dataset.id)
def tweet_new_post_task(post_id): try: twitter = Twitter() except: return post = Post.objects.get(id=post_id) is_mod = post.author.is_administrator_or_moderator() if is_mod or post.author.reputation > askbot_settings.MIN_REP_TO_TWEET_ON_OTHERS_ACCOUNTS: tweeters = User.objects.filter(social_sharing_mode=const.SHARE_EVERYTHING) tweeters = tweeters.exclude(id=post.author.id) access_tokens = tweeters.values_list('twitter_access_token', flat=True) else: access_tokens = list() tweet_text = post.as_tweet() for raw_token in access_tokens: token = simplejson.loads(raw_token) twitter.tweet(tweet_text, access_token=token) if post.author.social_sharing_mode != const.SHARE_NOTHING: token = simplejson.loads(post.author.twitter_access_token) twitter.tweet(tweet_text, access_token=token)
def test_create_put_twice(self): new_dataset = { 'name': 'New dataset!', 'description': 'Its got yummy data!' } response = self.client.put('/api/1.0/dataset/new-slug/', content_type='application/json', data=json.dumps(new_dataset), **self.auth_headers) self.assertEqual(response.status_code, 201) update_dataset = { 'name': 'Updated dataset!' } body = json.loads(response.content) self.assertEqual(body['name'], 'New dataset!') self.assertEqual(body['slug'], 'new-slug') dataset_id = body['id'] response = self.client.put('/api/1.0/dataset/new-slug/', content_type='application/json', data=json.dumps(update_dataset), **self.auth_headers) self.assertEqual(response.status_code, 202) body = json.loads(response.content) self.assertEqual(body['name'], 'Updated dataset!') self.assertEqual(body['slug'], 'new-slug') self.assertEqual(body['id'], dataset_id) # One dataset is created by setup self.assertEqual(Dataset.objects.all().count(), 2)
def testEnrollUser(self): c = self.login("admin", "test") user = User.objects.get(username="******") course = Course.objects.all()[0] user.courses.remove(course) url = "/siteadmin/users/%d/enroll/" % user.id self.assertFalse(user.courses.filter(id=course.id).exists()) response = c.post(url, {"course_id": course.id}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertTrue(json_response["success"]) self.assertTrue(user.courses.filter(id=course.id).exists()) response = c.post(url, {"course_id": course.id}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertTrue(json_response["success"]) self.assertTrue(user.courses.filter(id=course.id).exists()) response = c.post(url, {"course_id": 12309123098120398}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertFalse(json_response["success"])
def test_update_annotation(self): annot = Annotation.annotations.active()[0] self.api_client.login(username='******', password='******') url = reverse('annotation_handler', kwargs=dict(creator_id=1, annotation_id=annot.id) ) data=''' {"annotation": { "text": "Annotation body TEST updated", "type": "Comment", "target": [ {"url": "http://dlib.nyu.edu/awdl/books/derportrtkopfd00borc/test"} ] } }''' resp = self.api_client.put( url, data=data, content_type="application/json; charset=UTF-8", ) eq_(resp.status_code, 200) eq_( simplejson.loads(resp.content)['text'], simplejson.loads(data)['annotation']['text'], ) eq_( Annotation.annotations.active().get(id=annot.id).text, "Annotation body TEST updated" )
def testCampListAuth(self): user, key = AUTHS['playaevents'] seed = random.randint(0,1000000000) url = sign_url('/events/api/%s/2011/camp/' % APIS['playaevents'], user, key, seed=str(seed)) response = self.client.get(url) self.assertEqual(response.status_code, 200) # use one of the camps to get details camps = simplejson.loads(response.content) self.assert_(len(camps) > 0) camp = random.choice(camps) seed += 1 url = sign_url('/events/api/%s/2011/camp/%i/' % (APIS['playaevents'], camp['id']), user, key, seed=str(seed)) response = self.client.get(url) self.assertEqual(response.status_code, 200) camp2 = simplejson.loads(response.content) self.assert_(len(camp2) > 0) camp2 = camp2[0] keys1 = camp.keys() keys2 = camp.keys() keys1.sort() keys2.sort() self.assertEqual(keys1, keys2) for key in keys1: self.assertEqual(camp[key], camp2[key])
def testRemoveUserFromCourse(self): c = self.login("admin", "test") course = Course.objects.all()[0] url = "/siteadmin/courses/%d/remove_user/" % course.id user = course.users.all()[0] self.assertTrue(course.users.filter(id=user.id).exists()) # user is in course response = c.post(url, {"username": user.username}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertTrue(json_response["success"]) self.assertFalse(course.users.filter(username=user.username).exists()) response = c.post(url, {"username": user.username}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertFalse(json_response["success"]) response = c.post(url, {"username": "******"}) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertFalse(json_response["success"]) response = c.post(url) self.assertEqual(response.status_code, 200) json_response = json.loads(response.content) self.assertFalse(json_response["success"])
def test_layer_acls(self): """ Verify that the layer_acls view is behaving as expected """ # Test that HTTP_AUTHORIZATION in request.META is working properly valid_uname_pw = "%s:%s" % (settings.GEOSERVER_CREDENTIALS[0],settings.GEOSERVER_CREDENTIALS[1]) invalid_uname_pw = "%s:%s" % ("n0t", "v@l1d") valid_auth_headers = { 'HTTP_AUTHORIZATION': 'basic ' + base64.b64encode(valid_uname_pw), } invalid_auth_headers = { 'HTTP_AUTHORIZATION': 'basic ' + base64.b64encode(invalid_uname_pw), } # Test that requesting when supplying the GEOSERVER_CREDENTIALS returns the expected json expected_result = {'rw': [],'ro': [],'name': settings.GEOSERVER_CREDENTIALS[0],'is_superuser': True,'is_anonymous': False} c = Client() response = c.get('/data/acls', **valid_auth_headers) response_json = json.loads(response.content) self.assertEquals(expected_result, response_json) # Test that requesting when supplying invalid credentials returns the appropriate error code response = c.get('/data/acls', **invalid_auth_headers) self.assertEquals(response.status_code, 401) # Test logging in using Djangos normal auth system c.login(username='******', password='******') # Basic check that the returned content is at least valid json response = c.get("/data/acls") response_json = json.loads(response.content)
def test_people_friends_filter_by_has_app(self): """ Tests /people/1/@friends filtered by hasApp """ path = '/people/1/@friends' params = { 'xoauth_requestor_id': 1, 'filterBy' : 'hasApp', 'count' : 500, } headers = self.get_headers(path, 'GET', params) res = self.client.get(path, params, **headers) self.assertEquals(res.status_code, 200) data1 = json.loads(res.content) self.assertEqual(all([x['hasApp'] for x in data1.get('entry')]), True) params = { 'xoauth_requestor_id': 1, 'count' : 500, } headers = self.get_headers(path, 'GET', params) res = self.client.get(path, params, **headers) self.assertEquals(res.status_code, 200) data2 = json.loads(res.content) self.assertEqual([x['id'] for x in data1.get('entry') if x['hasApp']], [x['id'] for x in data2.get('entry') if x['hasApp']])
def test_keys_collection_get(self): resp = self.client.get(self.keys_url) self.assertEqual(resp.content, "[]") PublicKeyPair.objects.create(user=self.user, name="key pair 1", content="content1") resp = self.client.get(self.keys_url) resp_list = json.loads(resp.content); exp_list = [{"content": "content1", "id": 1, "uri": self.keys_url + "/1", "name": "key pair 1", "fingerprint": "unknown fingerprint"}] self.assertEqual(resp_list, exp_list) PublicKeyPair.objects.create(user=self.user, name="key pair 2", content="content2") resp = self.client.get(self.keys_url) resp_list = json.loads(resp.content) exp_list = [{"content": "content1", "id": 1, "uri": self.keys_url + "/1", "name": "key pair 1", "fingerprint": "unknown fingerprint"}, {"content": "content2", "id": 2, "uri": self.keys_url + "/2", "name": "key pair 2", "fingerprint": "unknown fingerprint"}] self.assertEqual(resp_list, exp_list)
def get(self): for i in range(10): error = random.choice(range(4)) project = 'frontend' try: if error == 0: x = 10 / 0 project = 'backend' elif error == 1: json.loads('{"abc", [1, 2') elif error == 2: x = {} y = x['y'] elif error == 3: x = {} y = x['z'] except: excInfo = sys.exc_info() stack = traceback.format_exc() env = random.choice(['']) exception = { 'timestamp': time.time(), 'project': project, 'serverName':'%s %s %d' % (env, project, random.choice(range(3))), 'type': excInfo[0].__module__ + '.' + excInfo[0].__name__, 'environment': env, 'message': str(excInfo[1]), 'logMessage': 'Log message goes here', 'backtrace': stack, 'context':{'userId':random.choice(range(20))} } putException(exception) self.response.out.write('Done!')
def test_people_self_with_xoauth_requestor_id(self): """ Tests people_self """ params = { 'xoauth_requestor_id': 1 } path = '/people/1/@self' headers = self.get_headers(path, 'GET', params) res = self.client.get(path, params, **headers) self.failUnlessEqual(res.status_code, 200) data = json.loads(res.content) self.assertEqual(data['entry']['isOwner'], True) self.assertEqual(data['entry']['isViewer'], True) # invalid xoauth_requestor_id params = { 'xoauth_requestor_id': 0 } path = '/people/1/@self' headers = self.get_headers(path, 'GET', params) res = self.client.get(path, params, **headers) self.failUnlessEqual(res.status_code, 200) data = json.loads(res.content) self.assertEqual(data['entry']['isOwner'], False) self.assertEqual(data['entry']['isViewer'], False) # Getting another's page params = { 'xoauth_requestor_id': 1 } path = '/people/3/@self' headers = self.get_headers(path, 'GET', params) res = self.client.get(path, params, **headers) self.failUnlessEqual(res.status_code, 200) data = json.loads(res.content) self.assertEqual(data['entry']['isOwner'], False) self.assertEqual(data['entry']['isViewer'], False)
def create(self, request, workspace_id, tab_id): user = get_user_authentication(request) if 'igadget' not in request.POST: return HttpResponseBadRequest(get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') # Data checking and parsing try: igadget = simplejson.loads(request.POST['igadget']) except: return HttpResponseBadRequest(get_xml_error(_('iGadget data is not valid JSON'))) initial_variable_values = None if 'variable_values' in request.POST: try: initial_variable_values = simplejson.loads(request.POST['variable_values']) except: return HttpResponseBadRequest(get_xml_error(_('variables_values must be a valid JSON value'))) # iGadget creation try: tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) igadget = SaveIGadget(igadget, user, tab, initial_variable_values) igadget_data = get_igadget_data(igadget, user, tab.workspace) return HttpResponse(json_encode(igadget_data), mimetype='application/json; charset=UTF-8') except Gadget.DoesNotExist, e: msg = _('referred gadget %(gadget_uri)s does not exist.') % {'gadget_uri': igadget['gadget']} raise TracedServerError(e, {'igadget': igadget, 'user': user, 'tab': tab}, request, msg)
def testCampListNoAuth(self): """Test getting an unauthenticated camp list""" url = '/events/api/%s/2011/camp/' % APIS['playaevents'] response = self.client.get(url) self.assertEqual(response.status_code, 200) # use one of the camps to get details camps = simplejson.loads(response.content) self.assert_(len(camps) > 0) camp = random.choice(camps) response = self.client.get('%s%i/' % (url, camp['id'])) self.assertEqual(response.status_code, 200) camp2 = simplejson.loads(response.content) self.assert_(len(camp2) > 0) camp2 = camp2[0] keys1 = camp.keys() keys2 = camp.keys() keys1.sort() keys2.sort() self.assertEqual(keys1, keys2) for key in keys1: self.assertEqual(camp[key], camp2[key])
def test_get_stats(self): # Get all of the cpu-system stat data response = test_get_rest_data( 'v1/stats/data/local/controller/192.168.1.1/cpu-system', { 'start-time': make_timestamp(1, 0), 'end-time': make_timestamp(10, 11), 'sample-interval': 0 }) self.assertEqual(response.status_code, 200) results = simplejson.loads(response.content) self.check_stats_results( results, self.STATS_DATA['controller-stats']['192.168.1.1']['cpu-system']) # Get just one days data of the cpu-system stat response = test_get_rest_data( 'v1/stats/data/local/controller/192.168.1.1/cpu-system', { 'start-time': make_timestamp(1, 0), 'end-time': make_timestamp(1, 4), 'sample-interval': 0 }) self.assertEqual(response.status_code, 200) results = simplejson.loads(response.content) self.check_stats_results( results, self.STATS_DATA['controller-stats']['192.168.1.1'] ['cpu-system'][:5]) # Get two day range for cpu-system response = test_get_rest_data( 'v1/stats/data/local/controller/192.168.1.1/cpu-system', { 'start-time': make_timestamp(1, 2, 10), 'end-time': make_timestamp(2, 2, 20), 'sample-interval': 0 }) self.assertEqual(response.status_code, 200) results = simplejson.loads(response.content) self.check_stats_results( results, self.STATS_DATA['controller-stats']['192.168.1.1'] ['cpu-system'][3:7]) # Get all of the flow-count switch stat data response = test_get_rest_data( 'v1/stats/data/local/switch/00:01:02:03:04:05/flow-count', { 'start-time': make_timestamp(1, 0), 'end-time': make_timestamp(2, 0), 'sample-interval': 0 }) self.assertEqual(response.status_code, 200) results = simplejson.loads(response.content) self.check_stats_results( results, self.STATS_DATA['switch-stats']['00:01:02:03:04:05']['flow-count']) # Get part of the packet-count switch stat data response = test_get_rest_data( 'v1/stats/data/local/switch/00:01:02:03:04:05/packet-count', { 'start-time': make_timestamp(1, 0), 'end-time': make_timestamp(1, 1), 'sample-interval': 0 }) self.assertEqual(response.status_code, 200) results = simplejson.loads(response.content) self.check_stats_results( results, self.STATS_DATA['switch-stats']['00:01:02:03:04:05'] ['packet-count'][:2])
def load_context_data(self): if self.context == '': self.context = '{}' self.context_data = simplejson.loads(self.context) return self.context_data
def test_PATCH_detail(self): ''' Test PATCH request to the detail endpoint. Check if specific fields have been updated successfully. ''' # sign in sign_in_resp = client.get('/{0}/me/'.format(self.api), data={ "user": self.userprofile[0].username, "password": "******", "stay_signed_in": "True" }) # check that sign-in was successful self.assertEqual( sign_in_resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=sign_in_resp.status_code)) itemtag = self.itemtag[0] # create test object to PATCH to the server new_item = self.item[1] new_image = self.image[1] new_owner = self.userprofile[ 1] # owner must be person who signs in. otherwise, it will be overwritten by default to be the person who signs in image_uri = construct_detail_uri( version=self.api, resource=ImageResource._meta.resource_name, uuid=new_image.uuid) item_uri = construct_detail_uri( version=self.api, resource=ItemResource._meta.resource_name, uuid=new_item.uuid) owner_uri = construct_detail_uri( version=self.api, resource=UserResource._meta.resource_name, uuid=new_owner.uuid) x = 1 y = 1 num = 100 t = itemtag.created_time PATCH_data = { 'item': item_uri, 'image': image_uri, 'x': y, 'y': x, 'num': num, 'owner': owner_uri, 'created_time': datetime.datetime(1, 1, 1, 0, 0, 0, 0, t.tzinfo).isoformat(), 'updated_time': datetime.datetime(1, 1, 1, 0, 0, 0, 0, t.tzinfo).isoformat(), 'resource_uri': 'NA' } # PATCH object to detail URI resp = client.patch(self.detail_uri, data=PATCH_data) # check status code if object was successfully updated self.assertEqual( resp.status_code, 202, 'Status code should be 202. Instead, it is {status_code}.'.format( status_code=resp.status_code)) # URI of the new object that is created in the database new_uri = json.loads(resp.content)['resource_uri'] # data of GETting new_uri GET_resp = client.get(new_uri, data=None) GET_data = json.loads(GET_resp.content) # make sure writable PATCHed fields are updated, unmodifiable fields are are not updated # if an AssertionError occurs here, check self.writeable_fields and verify the write permissions on that field for field, is_writable in self.fields.iteritems(): if is_writable: # if the field is writable, show that the fields are updated self.assertEqual( PATCH_data[field], GET_data[field], 'GET Value for writable Field \'{field}\' differs from PATCHed Value. They should be the same.' .format(field=field)) else: # if the field is not writable, show that the fields are not equal self.assertNotEqual( PATCH_data[field], GET_data[field], 'GET Value for non-writable Field \'{field}\' is the same as the PATCHed Value. They should be different.' )
def render(self, name, value, *args, **kwargs): if value is None: lat, lon, address = DEFAULT_LAT, DEFAULT_LNG, DEFAULT_ADDRESS value = {'lat': lat, 'lon': lon, 'address': address} else: value = json.loads(value) lat, lon, address = float(value['lat']), float(value['lon']), value['address'] curLocation = json.dumps(value, cls=DjangoJSONEncoder) js = ''' <script type="text/javascript"> //<![CDATA[ var map_%(id)s; function save_position_%(id)s(point, address) { var input = document.getElementById("id_%(name)s"); var location = {'lat':point.getLat().toFixed(12), 'lon':point.getLon().toFixed(12)}; location.address = '%(address)s'; if (address) { location.address = address; } input.value = JSON.stringify(location); document.getElementById('address_%(name)s').value = location.address; var marker = new DG.Markers.Common({geoPoint:point}); map_%(id)s.markers.removeAll(); map_%(id)s.markers.add(marker); map_%(id)s.setCenter(point, 16); map_%(id)s.geocoder.get(point, { types: ['district'], success: function(geocoderObjects) { var district = geocoderObjects[0].getShortName(); if ( district ) { if ( $('#id_1-map2gis_district').length ) { $('#id_1-map2gis_district').val(district); console.log(district); } } } }); } function load_%(id)s() { map_%(id)s = new DG.Map("map_%(name)s"); map_%(id)s.controls.add(new DG.Controls.Zoom()); var point = new DG.GeoPoint(%(lon)f, %(lat)f); map_%(id)s.setCenter(point, 16); if ('%(address)s' && %(lon)f && %(lat)f) { var marker = new DG.Markers.Common({geoPoint: point}); map_%(id)s.markers.add(marker); } map_%(id)s.addEventListener(map_%(id)s.getContainerId(), 'DgClick', function(evt){ map_%(id)s.geocoder.get(evt.getGeoPoint(), { types: ['district', 'street', 'living_area', 'place', 'house'], success: function(geocoderObjects) { save_position_%(id)s(geocoderObjects[0].getCenterGeoPoint(), geocoderObjects[0].getName()); } }); }); $('#address_%(name)s').autocomplete({ source: function(request, response) { if (request.term.length > 2) { map_%(id)s.geocoder.get(request.term, { types: ['district', 'street', 'living_area', 'place', 'house'], limit: 10, success: function(geocoderObjects) { response($.map(geocoderObjects, function(item) { return { value: item.getName(), location: item.getCenterGeoPoint() } })); } }); } }, select: function(event, ui) { save_position_%(id)s(ui.item.location, ui.item.value); } }); $('#address_%(name)s').focusout(function(){ save_position_%(id)s(map_%(id)s.getCenter(), $('#address_%(name)s').val()); }); } $(document).ready(function(){ load_%(id)s(); }); //]]> </script> ''' % dict(id=name.replace('-', '_'), name=name, lat=lat, lon=lon, address=address) html = self.inner_widget.render("%s" % name, "%s" % curLocation, dict(id='id_%s' % name)) html += u'<div id="map_%s" style="width:%dpx; height:%dpx"></div>' % ( name, self.map_width, self.map_height) html += u'<label>%s: </label><input id="address_%s" type="text" style="width:200px" />' \ u'<br />' % (u'Поиск по адресу', name) html += u'<span class="def_address">Текущий адрес: %s</span>' % ( address if address else u'(Не указан)',) return mark_safe(html + js)
def test_mary_index(self): response = self.run_get('mary', '/api/budgetline', {'budget': 33}) result = simplejson.loads(response.content) self.assertEquals(response.status_code, 200) self.assertEquals(len(result), 1) self.assertEquals(result[0]['total_amount'], '200')
def fetch_json(url, service, list_key=None): fetched = urlopen(url).read() data = json.loads(fetched) if list_key: data = data[list_key] return data
def testPartyAPI(self): res = self.client.get(reverse('party-handler')) #, kwargs={'object_id': self.mk_1.id}),{'verbs':'posted'}) self.assertEqual(res.status_code,200) parties = json.loads(res.content) self.assertEqual(map(lambda x:x['id'], parties), [self.party_1.id, self.party_2.id])
def _get_pk_values(serial_str): ret_list = [] serial_list = simplejson.loads(serial_str) for obj_dict in serial_list: ret_list.append(obj_dict["pk"]) return ret_list
def test_api_tag(self): res = self.client.get( self._reverse_api('api_dispatch_detail', pk=self.tags[0].id)) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(res_json['name'], self.tags[0].name)
def test_GET_list(self): ''' Test GET request to the list endpoint. Check if the returned fields are correct. ''' # sign in ? itemtag = self.itemtag[0] image = self.image[0] # GET ItemTag list resp = client.get('{list_uri}?limit=0'.format(list_uri=self.list_uri), data=None) # check status code if object was successfully received self.assertEqual( resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=resp.status_code)) GET_data = json.loads(resp.content) # check list dictionary self.assertTrue('meta' in GET_data, 'GET list should return a Field \'meta\'') self.assertTrue('objects' in GET_data, 'GET list should return a Field \'objects\'') # assuming tastypie GET list endpoint works... self.assertEqual( len(GET_data['objects']), ItemTag.objects.filter(is_active=True).count(), 'Number of returned elements does not match number of objects in the database' ) # Filters # Image image_uri = construct_detail_uri(version=self.api, resource='image', uuid=image.uuid) # set limit=0 so that all the objects are returned (not paginated) resp = client.get('{itemtag_uri}?image={image_uri}&limit=0'.format( itemtag_uri=self.list_uri, image_uri=image_uri)) # check status code if object was successfully received self.assertEqual( resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=resp.status_code)) GET_data = json.loads(resp.content) # check if the the number of filtered objects is correct filtered_itemtag_uuids = ItemTag.objects.filter( is_active=True, image=image).values_list('uuid', flat=True) self.assertEqual( len(GET_data['objects']), filtered_itemtag_uuids.count(), 'Number of returned filtered elements does not match number of filtered objects in the database' ) # check that the objects in the list is what you would get from the database for obj in GET_data['objects']: uuid = parse_uri(obj['resource_uri'])['uuid'] self.assertTrue( uuid in filtered_itemtag_uuids, 'Returned object in list does not match any returned object from the database' )
def test_GET_detail(self): ''' Test GET request to the detail endpoint. Check if the returned fields are correct. Also check for proper filtering. ''' # sign in ? item = self.item[0] # GET Item detail resp = client.get(self.detail_uri, data=None) # check status code if object was successfully received self.assertEqual( resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=resp.status_code)) GET_data = json.loads(resp.content) # check the number of returned fields self.assertEqual( len(GET_data), len(self.fields), 'Total number of fields outputed is {wrong_num}. It should be {right_num}.' .format(wrong_num=len(GET_data), right_num=len(self.fields))) # make sure all the right fields are outputed in the API for key in self.fields: self.assertTrue( key in GET_data, 'Field \'{field}\' is not in the returned JSON object.'.format( field=key)) # check the accuracy of each field self.assertEqual(GET_data['name'], item.name, 'Value for Field \'name\' is incorrect.') self.assertEqual(GET_data['brand_name'], item.brand_name, 'Value for Field \'brand_name\' is incorrect.') self.assertEqual(GET_data['description'], item.description, 'Value for Field \'description\' is incorrect.') self.assertEqual(GET_data['size'], item.size, 'Value for Field \'size\' is incorrect.') self.assertEqual(GET_data['color'], item.color, 'Value for Field \'color\' is incorrect.') self.assertEqual(GET_data['price'], item.price, 'Value for Field \'price\' is incorrect.') self.assertEqual(GET_data['url'], item.url, 'Value for Field \'price\' is incorrect.') self.assertEqual(GET_data['total_comments'], item.total_comments(), 'Value for Field \'total_comments\' is incorrect.') self.assertEqual(GET_data['total_votes'], item.total_votes(), 'Value for Field \'total_votes\' is incorrect.') # take out microsecond and use timezone javascript standard t = item.created_time self.assertEqual( GET_data['created_time'], datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second, 0, t.tzinfo).isoformat(), 'Value for Field \'created_time\' is incorrect.') t = item.updated_time self.assertEqual( GET_data['updated_time'], datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second, 0, t.tzinfo).isoformat(), 'Value for Field \'updated_time\' is incorrect.') owner_uri = construct_detail_uri( version=self.api, resource=UserResource._meta.resource_name, uuid=item.owner.uuid) self.assertEqual(GET_data['owner'], owner_uri, 'Value for Field \'owner\' is incorrect.') item_uri = construct_detail_uri( version=self.api, resource=ItemResource._meta.resource_name, uuid=item.uuid) comment_filter_uri = construct_filter_uri( version=self.api, resource=CommentResource._meta.resource_name, parameter='parent', filter_uri=item_uri) self.assertEqual(GET_data['comment'], comment_filter_uri, 'Value for Field \'comment\' is incorrect.') vote_filter_uri = construct_filter_uri( version=self.api, resource=VoteResource._meta.resource_name, parameter='parent', filter_uri=item_uri) self.assertEqual(GET_data['vote'], vote_filter_uri, 'Value for Field \'vote\' is incorrect.') resource_uri = construct_detail_uri(version=self.api, resource=self.resource_name, uuid=item.uuid) self.assertEqual(GET_data['resource_uri'], resource_uri, 'Value for Field \'resource_uri\' is incorrect.')
def test_POST_list(self): ''' Test POST request to the list endpoint. Check if the posted information is correct. ''' # POST a new itemtag to the backend user = self.userprofile[0] # sign in sign_in_resp = client.get('/{version}/me/'.format(version=self.api), data={ "user": user.username, "password": "******", "stay_signed_in": "True" }) # check that sign-in was successful self.assertEqual( sign_in_resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=sign_in_resp.status_code)) # record initial number of itemtag objects initial_num_itemtags = ItemTag.objects.filter(is_active=True).count() # create test object to POST to the server new_item = self.item[1] new_image = self.image[1] new_owner = user # owner must be person who signs in. otherwise, it will be overwritten by default to be the person who signs in image_uri = construct_detail_uri( version=self.api, resource=ImageResource._meta.resource_name, uuid=new_image.uuid) item_uri = construct_detail_uri( version=self.api, resource=ItemResource._meta.resource_name, uuid=new_item.uuid) owner_uri = construct_detail_uri( version=self.api, resource=UserResource._meta.resource_name, uuid=new_owner.uuid) x = .7 y = .8 num = 1 POST_data = { 'image': image_uri, 'item': item_uri, 'owner': owner_uri, 'num': num, 'x': x, 'y': y } # POST object to list URI resp = client.post(self.list_uri, data=POST_data) # check status code if object was successfully created self.assertEqual( resp.status_code, 201, 'Status code should be 201. Instead, it is {status_code}.'.format( status_code=resp.status_code)) # URI of the new object that is created in the database new_uri = json.loads(resp.content)['resource_uri'] # data of GETting new_uri GET_resp = client.get(new_uri, data=None) GET_data = json.loads(GET_resp.content) # make sure posted object exists self.assertEqual( resp.status_code, 201, 'Status code should be 201. Instead, it is {status_code}.'.format( status_code=resp.status_code)) self.assertEqual( POST_data['image'], GET_data['image'], 'GET Value for Field \'image\' differs from POSTed Value') self.assertEqual( POST_data['item'], GET_data['item'], 'GET Value for Field \'item\' differs from POSTed Value') self.assertEqual( POST_data['owner'], GET_data['owner'], 'GET Value for Field \'owner\' differs from POSTed Value') self.assertEqual( POST_data['num'], GET_data['num'], 'GET Value for Field \'owner\' differs from POSTed Value') self.assertEqual( POST_data['x'], GET_data['x'], 'GET Value for Field \'x\' differs from POSTed Value') self.assertEqual( POST_data['y'], GET_data['y'], 'GET Value for Field \'y\' differs from POSTed Value') # check that the number of itemtags has increased by 1 final_num_itemtags = ItemTag.objects.filter(is_active=True).count() self.assertEqual( initial_num_itemtags + 1, final_num_itemtags, 'Total number of objects (after posting) is not correct')
def delete_notifications(request): post_data = simplejson.loads(request.raw_post_data) memo_set = models.ActivityAuditStatus.objects.filter( id__in=post_data['memo_ids'], user=request.user) memo_set.delete() request.user.update_response_counts()
def test_GET_detail(self): ''' Test GET request to the detail endpoint. Check if the returned fields are correct. Also check for proper filtering. ''' # sign in ? itemtag = self.itemtag[0] # GET ItemTag detail resp = client.get(self.detail_uri, data=None) # check status code if object was successfully received self.assertEqual( resp.status_code, 200, 'Status code should be 200. Instead, it is {status_code}.'.format( status_code=resp.status_code)) GET_data = json.loads(resp.content) # check the number of returned fields self.assertEqual( len(GET_data), len(self.fields), 'Total number of fields outputed is {wrong_num}. It should be {right_num}.' .format(wrong_num=len(GET_data), right_num=len(self.fields))) # make sure all the right fields are outputed in the API for key in self.fields: self.assertTrue( key in GET_data, 'Field \'{field}\' is not in the returned JSON object.'.format( field=key)) # check the accuracy of each field self.assertEqual(GET_data['num'], itemtag.num, 'Value for Field \'num\' is incorrect.') self.assertEqual(GET_data['x'], itemtag.x, 'Value for Field \'x\' is incorrect.') self.assertEqual(GET_data['y'], itemtag.y, 'Value for Field \'y\' is incorrect.') # take out microsecond and use timezone javascript standard t = itemtag.created_time self.assertEqual( GET_data['created_time'], datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second, 0, t.tzinfo).isoformat(), 'Value for Field \'created_time\' is incorrect.') t = itemtag.updated_time self.assertEqual( GET_data['updated_time'], datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second, 0, t.tzinfo).isoformat(), 'Value for Field \'updated_time\' is incorrect.') owner_uri = construct_detail_uri( version=self.api, resource=UserResource._meta.resource_name, uuid=itemtag.owner.uuid) self.assertEqual(GET_data['owner'], owner_uri, 'Value for Field \'owner\' is incorrect.') image_uri = construct_detail_uri(version=self.api, resource=itemtag.image.obj_type(), uuid=itemtag.image.uuid) self.assertEqual(GET_data['image'], image_uri, 'Value for Field \'image\' is incorrect.') item_uri = construct_detail_uri(version=self.api, resource=itemtag.item.obj_type(), uuid=itemtag.item.uuid) self.assertEqual(GET_data['item'], item_uri, 'Value for Field \'item\' is incorrect.') resource_uri = construct_detail_uri(version=self.api, resource=self.resource_name, uuid=itemtag.uuid) self.assertEqual(GET_data['resource_uri'], resource_uri, 'Value for Field \'resource_uri\' is incorrect.')
def loads(txt): value = simplejson.loads(txt, parse_float=Decimal, encoding=settings.DEFAULT_CHARSET) assert isinstance(value, dict) return value
costs_dict[a] = 1 sf = f wp = create_wp(target_dict, penalty_dict, costs_dict, sf) ############ print "####################################" print 'targets', wp.input_targets print 'penalties', wp.input_penalties print 'costs', wp.input_relativecosts wp.save() while not wp.done: time.sleep(2) print " ", wp.status_html inpenalties = json.loads(wp.input_penalties) intargets = json.loads(wp.input_targets) if 'widespread' in inpenalties.keys(): nspecies = 71 else: nspecies = len(inpenalties.keys()) r = wp.results #'ncosts, nspecies, sumpenalties, meanpenalties, scalefactor, meantarget, numspeciesmet, numplannningunits' fh.write(','.join([str(x) for x in [ sum(json.loads(wp.input_relativecosts).values()), nspecies, sum(inpenalties.values()), mean(inpenalties.values()),
def test_api_party_list(self): res = self.client.get(reverse('party-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 1) self.assertEqual(res_json[0]["name"], self.party_1.name)
def post(self, *args, **kwargs): form_dict = simplejson.loads(self.request.POST['form']) form = Form.get_by_name(kwargs['name']) form.update_from_dict(form_dict) return http.HttpResponse(_(u'Form updated with success'))
def test_api_member_list(self): res = self.client.get(reverse('member-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), self.num_mks)
def get_param(self, key): return simplejson.loads(self.params)[key]
def test_api_agenda(self): res = self.client.get(reverse('agenda-handler', args=[self.agenda.id])) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(res_json['name'], self.agenda.name)
def test_api_member(self): res = self.client.get(reverse('member-handler', args=[self.mks[0].id])) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(res_json['name'], self.mks[0].name)
def test_api_tag_for_vote(self): res = self.client.get( reverse('tag-handler', args=['laws', 'vote', self.vote_1.id])) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 2)
def testEventlList(self): res = self.client.get(reverse('event-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 1) self.assertEqual(res_json[0]['what'], 'ev2')
def test_api_vote(self): res = self.client.get(reverse('vote-handler', args=[self.vote_1.id])) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json['for_votes']), self.num_mks)
def test_api_agenda_list(self): res = self.client.get(reverse('agenda-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 1)
def from_json(self, content): """ Given some JSON data, returns a Python dictionary of the decoded data. """ return simplejson.loads(content)
def test_api_bill_list_with_days_back(self): res = self.client.get('%s?days_back=2' % reverse('bill-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 1) self.assertEqual(len(res_json[0]['proposing_mks']), 1)
def get_my_profile(self, access_token): from social_urls import gmail_urls user_info = urllib2.urlopen(gmail_urls['get_user_profile'] % access_token) return simplejson.loads(user_info.read())
def test_api_vote_list(self): res = self.client.get(reverse('vote-handler')) self.assertEqual(res.status_code, 200) res_json = json.loads(res.content) self.assertEqual(len(res_json), 1) self.assertEqual(len(res_json[0]['for_votes']), self.num_mks)