Python Headers.add方法代码示例

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def test_subscription_remove_period(client, session):
    password = "password"
    user = UserFactory(active=True, password=password)
    author = AuthorFactory()
    sub = SubscriptionFactory(user=user, author=author, active=True)
    sub.add_period(PERIOD.DAILY)

    assert sub.has_period(PERIOD.DAILY)
    assert len(sub.periods) == 1

    h = Headers()
    auth = requests.auth._basic_auth_str(user.email, password)
    h.add("Authorization", auth)
    url = "{0}{1}{2}{3}".format(
        url_for("subscriptions.remove_period"),
        "?period=Daily",
        "&subscription_id=",
        str(sub.id),
    )

    response = client.post(url, headers=h)

    assert response.status_code == 302

    assert len(sub.periods) == 0
    assert sub.has_period(PERIOD.DAILY) is False

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
 def test07_access_token_handler(self):
     with dummy_app.test_request_context('/a_request'):
         auth = IIIFAuthBasic()
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/json' )
         j = json.loads(response.get_data())
         self.assertEqual( j['error_description'], "No login details received" )
         self.assertEqual( j['error'], "client_unauthorized" )
     # add Authorization header, check we get token
     h = Headers()
     h.add('Authorization', 'Basic ' + base64.b64encode('userpass:userpass'))
     with dummy_app.test_request_context('/a_request', headers=h):
         auth = IIIFAuthBasic()
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/json' )
         j = json.loads(response.get_data())
         self.assertEqual( j['access_token'], "secret_token_here" ) #FIXME
         self.assertEqual( j['token_type'], "Bearer" )
         self.assertEqual( j['expires_in'], 3600 )
     # add callback but no Authorization header
     with dummy_app.test_request_context('/a_request?callback=CB'):
         auth = IIIFAuthBasic()
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/javascript' )
         # strip JavaScript wrapper and then check JSON
         js = response.get_data()
         self.assertTrue( re.match('CB\(.*\);',js) )
         j = json.loads(js.lstrip('CB(').rstrip(');'))
         self.assertEqual( j['error_description'], "No login details received" )
         self.assertEqual( j['error'], "client_unauthorized" )

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
	def test_info_conneg_415(self):
		self.app.redirect_conneg = False
		h = Headers()
		h.add('accept','text/plain')
		to_get = '/%s/info' % (self.test_jp2_color_id,)
		resp = self.client.get(to_get, headers=h, follow_redirects=True)
		self.assertEqual(resp.status_code, 415)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
	def test_image_conneg_redirect(self):
		self.app.redirect_conneg = True
		h = Headers()
		h.add('accept','image/jpeg')
		to_get = '/%s/full/full/0/native' % (self.test_jp2_color_id,)
		resp = self.client.get(to_get, headers=h, follow_redirects=False)
		self.assertEqual(resp.status_code, 301)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
 def test05_login_handler(self):
     """Test login_handler."""
     with dummy_app.test_request_context('/a_request'):
         auth = IIIFAuthBasic()
         response = auth.login_handler()
         self.assertEqual(response.status_code, 401)
         self.assertEqual(response.headers['Content-type'], 'text/html')
         html = response.get_data().decode('utf-8')  # data is bytes in python3
         self.assertEqual(html, '')
     # add good login params and check OK, window close
     h = Headers()
     h.add('Authorization', b'Basic ' +
           base64.b64encode(b'userpass:userpass'))
     with dummy_app.test_request_context('/a_request', headers=h):
         response = auth.login_handler()
         self.assertEqual(response.status_code, 200)
         html = response.get_data().decode('utf-8')
         self.assertTrue(
             re.search(
                 r'<script>window.close\(\);</script>',
                 html))
         set_cookie = response.headers['Set-Cookie']
         self.assertTrue(
             re.search(
                 auth.auth_cookie_name +
                 '=valid-http-basic-login',
                 set_cookie))
     # add bad login params and check fail
     h = Headers()
     h.add('Authorization', b'Basic ' +
           base64.b64encode(b'userpass:bad-pass'))
     with dummy_app.test_request_context('/a_request', headers=h):
         response = auth.login_handler()
         self.assertEqual(response.status_code, 401)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
    def build_headers(self, data_json=False):
        headers = Headers()

        if data_json:
            headers.add('Content-Type', 'application/json')

        return headers

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def create_task(name, url, queued_callback=None, parameters=None):

  # task name must be unique
  if not parameters:
    parameters = {}
  task = BackgroundTask(name=name + str(int(time())))
  task.parameters = parameters
  task.modified_by = get_current_user()
  db.session.add(task)
  db.session.commit()

  # schedule a task queue
  if getattr(settings, 'APP_ENGINE', False):
    from google.appengine.api import taskqueue
    headers = Headers(request.headers)
    headers.add('x-task-id', task.id)
    taskqueue.add(
        queue_name="ggrc",
        url=url,
        name="{}_{}".format(task.name, task.id),
        params={'task_id': task.id},
        method=request.method,
        headers=headers)
  elif queued_callback:
    queued_callback(task)
  return task

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def test_locale_negotiation(client, testdata):
    headers = Headers()
    headers.add("Accept-Language", testdata.header)

    res = client.get("/locale?available=" + testdata.available, headers=headers)
    assert res.status_code == 200
    assert res.json == {u"locale": testdata.result}

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
 def test_get_existing_node_informations(self):
     time.sleep(5)
     h = Headers()
     h.add("Authorization", self.valid_test_token)
     rv = self.client.get(self.node_resource_path, headers=h)
     for info in ["ip", "node", "state", "name"]:
         self.assertTrue(info in rv.data)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def fetch():
    url = request.form['url']
    print url
    try:
        h = Headers(request.headers)
        h.clear()
        h.add('referer', 'https://www.facebook.com/')

        r = requests.request(
            method='GET',
            url=url,
            headers=h,
            timeout=5
        )
    except (
            requests.exceptions.Timeout,
            requests.exceptions.ConnectTimeout,
            requests.exceptions.ReadTimeout):
        return Response(status=504)
    except (
            requests.exceptions.ConnectionError,
            requests.exceptions.HTTPError,
            requests.exceptions.TooManyRedirects):
        return Response(status=502)
    except (
            requests.exceptions.RequestException,
            Exception) as e:
        if app.debug:
            raise e
        return Response(status=500)

    mimetype = "text/html"
    return Response(r.content, mimetype=mimetype)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
 def test_admin_page_rejects_bad_username(self):
     """ Check that incorrect username won't allow access """
     h = Headers()
     auth = 'foo:{0}'.format(Config.PASSWORD).encode('ascii')
     h.add('Authorization', b'Basic ' + base64.b64encode(auth))
     rv = Client.open(self.client, path='/', headers=h)
     self.assert_401(rv)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
 def test07_access_token_handler(self):
     with dummy_app.test_request_context('/a_request'):
         auth = IIIFAuthGoogle(client_secret_file=csf)
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/json' )
         j = json.loads(response.get_data())
         self.assertEqual( j['error_description'], "No login details received" )
         self.assertEqual( j['error'], "client_unauthorized" )
     # add callback but no account cookie
     with dummy_app.test_request_context('/a_request?callback=CB'):
         auth = IIIFAuthGoogle(client_secret_file=csf)
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/javascript' )
         # strip JavaScript wrapper and then check JSON
         js = response.get_data()
         self.assertTrue( re.match('CB\(.*\);',js) )
         j = json.loads(js.lstrip('CB(').rstrip(');'))
         self.assertEqual( j['error_description'], "No login details received" )
         self.assertEqual( j['error'], "client_unauthorized" )
     # add an account cookie
     h = Headers()
     h.add('Cookie', 'lol_account=ACCOUNT_TOKEN')
     with dummy_app.test_request_context('/a_request', headers=h):
         auth = IIIFAuthGoogle(client_secret_file=csf, cookie_prefix='lol_')
         response = auth.access_token_handler()
         self.assertEqual( response.status_code, 200 )
         self.assertEqual( response.headers['Content-type'], 'application/json' )
         j = json.loads(response.get_data())
         self.assertEqual( j['access_token'], "ACCOUNT_TOKEN" )
         self.assertEqual( j['token_type'], "Bearer" )

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def song(id, ext):
	song = db.session.query(Song.id, Song.filename, Song.length, Song.mimetype, Song.artist, Song.album, Song.title, Song.track).filter(Song.id == id).first()
	if song == None or not os.path.exists(song.filename):
		return abort(404)
	headers = Headers()
	headers.add("X-Content-Duration", song.length)
	headers.add("X-Accel-Buffering", "no")
	range_header = request.headers.get('Range', None)
	if range_header is not None:
		range_header = range_header.split("-")
		try:
			range_header = intval(range_header[0])
		except:
			range_header = None
	if range_header is None or range_header == 0:
		db.session.add(Download(song, request))
		db.session.commit()
	
	ext = ext.lower()

	for extension, mimeset in mimetypes.items():
		if song.mimetype in mimeset and extension == ext:
			return send_file_partial(song.filename, mimetype=song.mimetype, attachment_filename=generate_download_filename(song, ext), headers=headers)

	if ext not in [ "ogg", "mp3", "flac", "wav", "webm" ]:
		return abort(404)
	transcode_options = [ 'avconv', '-loglevel', 'quiet', '-i', song.filename, '-f', ext, '-y', '-fflags', 'nobuffer' ];
	if ext == "ogg" or ext == "webm":
		transcode_options.extend([ '-acodec', 'libvorbis', '-aq', '5' ])
	elif ext == "mp3":
		transcode_options.extend([ '-ab', '160k' ])
	transcode_options.append('-')
	return send_process(transcode_options, mimetype=mimetypes[ext][0], attachment_filename=generate_download_filename(song, ext), headers=headers)

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
    def handler_b2s_image(self, id=None):
        """ Handler for `/b2s_image` url for json data.

        It accepts only Communication Kit Notifications.

        """
        if id is None:
            raise BadRequest()
        headers = request.httprequest.headers
        self._validate_headers(headers)
        correspondence_obj = request.env['correspondence'].sudo()
        correspondence = correspondence_obj.search([('uuid', '=', id)])
        if not correspondence:
            raise NotFound()
        data = correspondence.get_image()
        headers = Headers()
        if correspondence.letter_format == 'zip':
            fname = fields.Date.today() + ' letters.zip'
            headers.add(
                'Content-Disposition', 'attachment',
                filename=fname)
            response = Response(data, content_type='application/zip',
                                headers=headers)
        else:
            headers.add(
                'Content-Disposition', 'attachment',
                filename=correspondence.file_name)
            response = Response(data, content_type='application/pdf',
                                headers=headers)
        return response

# 需要导入模块: from werkzeug.datastructures import Headers [as 别名]
# 或者: from werkzeug.datastructures.Headers import add [as 别名]
def test_user_rss_url_etag(session, client):
    entries = EntryFactory.create_batch(5)
    author1 = AuthorFactory()
    author1.entries.extend(entries)
    user = UserFactory(active=True)
    user.userfeed.private = False
    sub1 = Subscription(user=user, author=author1)
    sub1.save()

    h = Headers()
    h.add("If-None-Match", None)
    response1 = client.get(url_for("users.user_feed", user_id=user.id), headers=h)

    assert response1.status_code == 200
    etag = response1.headers.get("ETag")
    assert response1.data
    assert (
        response1.headers.get("Content-Type") == "application/atom+xml; charset=utf-8"
    )

    h.add("If-None-Match", etag)
    response2 = client.get(url_for("users.user_feed", user_id=user.id), headers=h)

    assert response2.status_code == 304
    etag2 = response2.headers.get("ETag")
    assert etag2 == etag
    assert not response2.data