Develop Reference

How to test a Flask (non-route) function that processes a request, using pytest?

Context: I have two Flask routes which process the same request data (one interactively, one as an API). To keep my code DRY, I want to write a function process_post_request() that
accepts the request as in input parameter from each route,
parses the request,
returns results which the routes can use.
For example, in views.py:
#app.route('/interactive', methods=['GET', 'POST'])
def interactive():
if request.method == 'POST':
sum, product = process_post_request(request)
# present the results on a web page
#app.route('/api', methods=['GET', 'POST'])
def api():
if request.method == 'POST':
sum, product = process_post_request(request)
# return the results so that JavaScript can parse them
def process_post_request(request):
param1 = request.form.get('param1')
param2 = request.form.get('param2')
sum = param1 + param2
product = param1 * param2
return sum, product
Question: How can I write a pytest for process_post_request()? The problem is that if I create a "request" and try to pass it to process_post_request(), the request goes to a route, so that route returns a result. For example, in views_test.py:
import pytest
#pytest.fixture
def client():
"""Create a client to make requests from"""
with app.test_client() as client:
with app.app_context():
pass
yield client
def test_process_post_request():
request = client.post('/interactive', data={'param1': 5, 'param2': 7})
sum, product = process_post_request(request)
assert sum == 12
Because request returns a response, pytest throws this error:
> request = client.post('/interactive', data={'param1': 5, 'param2': 7})
E AttributeError: 'function' object has no attribute 'post'

I created an app route to return comma-separated parameters:
#app.route('/pass-through', methods = ['GET', 'POST'])
def pass_through():
if request.method == 'POST':
params = process_post_request(request)
return ','.join(params)
Then tested that app route:
def test_process_post_request():
with app.test_client() as client:
response = client.post('/pass-through', data={'param1': 5, 'param2': 7})
sum, product = response.data.decode().split(',')
assert sum == 12
where decode() translates from bytes to string.
It's not the most satisfying solution because it really tests the app route, so it depends on the app route function pass_through() using the same parameter names as process_post_request().

How to send a file to post method that accepts form data in python flask, and also how to retrieve file and other fields in the called method?

I'm trying something like this.
Caller code -
files = {'file': open(file_name, 'rb').read()}
response = requests.post(url, headers=headers, data=metadata, files=files)
Called method code-
metadata = {}
for key, value in request.form.items():
metadata[key] = value
print(metadata)
print(type(metadata))
print("Request data")
print(request.data)
print("Files")
print(request.files)
print(request.files is None)
print('file' not in request.files)
The output in called method is empty
{}
<class 'dict'>
Request data
b''
Files
ImmutableMultiDict([])
False
True
Can someone tell me how to fix this?

files = {'upload_file': open('file.txt','rb')}
values = {'DB': 'photcat', 'OUT': 'csv', 'SHORT': 'short'}
r = requests.post(url, files=files, data=values)
from flask import Flask, render_template, request, redirect, url_for
app = Flask(__name__)
#app.route('/')
def index():
return render_template('index.html')
#app.route('/', methods=['POST'])
def upload_file():
uploaded_file = request.files['file']
if uploaded_file.filename != '':
uploaded_file.save(uploaded_file.filename)
return redirect(url_for('index'))

Flask jsonify returns bytes and string instead of json object

In Postman post_new_cafe prints json as it suppose to be, but when I want to print it inside console and webpage it prints differently. See example below.
#app.route('/add_form', methods=['GET', 'POST'])
def add_new_cafe_form():
form = CafeForm()
if form.validate_on_submit():
response = post_new_cafe()
print(response)
return render_template("add.html", form=form)
This prints out
<Response 52 bytes [200 OK]>
and
#app.route('/add_form', methods=['GET', 'POST'])
def add_new_cafe_form():
form = CafeForm()
if form.validate_on_submit():
response = post_new_cafe()
print(response.response)
return render_template("add.html", form=form)
prints out
[b'{\n "success": "Successfully added the new cafe."\n}\n']
and this
#app.route('/add_form', methods=['GET', 'POST'])
def add_new_cafe_form():
form = CafeForm()
if form.validate_on_submit():
response = post_new_cafe()
print(response.json())
return render_template("add.html", form=form)
gives error
TypeError: 'dict' object is not callable
This is function that returns jsonify
# # HTTP POST - Create Record
#app.route('/add', methods=['POST'])
def post_new_cafe():
new_cafe = Cafe(
name=request.form.get('name'),
map_url=request.form.get('map_url'),
img_url=request.form.get('img_url'),
location=request.form.get('location'),
seats=request.form.get('seats'),
has_toilet=bool(strtobool(request.form.get('has_toilet'))),
has_wifi=bool(strtobool(request.form.get('has_wifi'))),
has_sockets=bool(strtobool(request.form.get('has_sockets'))),
can_take_calls=bool(strtobool(request.form.get('can_take_calls'))),
coffee_price=request.form.get('coffee_price')
)
# db.session.add(new_cafe)
# db.session.commit()
return jsonify(success="Successfully added the new cafe.")
I have tried this
resp = Response(response={"success":"Successfully added the new cafe."},
status=200,
mimetype="application/json")
return jsonify(resp)
and it's not working, also I have tried using make_response still nothing.
What I want is when I store post_new_cafe() into response variable to have this
response = post_new_cafe()
data = response.json()
print(data)
{"success": "Successfully added the new cafe."}
print(data["success"])
Successfully added the new cafe.

Hey you can solve this issue with the json library.
Example:
import json
def post_new_cafe():
new_cafe = Cafe(
name=request.form.get('name'),
map_url=request.form.get('map_url'),
img_url=request.form.get('img_url'),
location=request.form.get('location'),
seats=request.form.get('seats'),
has_toilet=bool(strtobool(request.form.get('has_toilet'))),
has_wifi=bool(strtobool(request.form.get('has_wifi'))),
has_sockets=bool(strtobool(request.form.get('has_sockets'))),
can_take_calls=bool(strtobool(request.form.get('can_take_calls'))),
coffee_price=request.form.get('coffee_price')
)
return json.dumps({"success": "Succesfully added the new cafe."})
response = post_new_cafe()
data = json.loads(response)
print(data)
print(data["success"])
For more information look at the Documentation about JSON
If you need to serialize a numpy array, there is a question on how to serialize a numpy array as JSON
Regarding your other issue:
#app.route('/add_form', methods=['GET', 'POST'])
def add_new_cafe_form():
form = CafeForm()
if form.validate_on_submit():
response = post_new_cafe()
print(response.json())
return render_template("add.html", form=form)
You need to convert the response from binary to string first: response.decode('utf-8') and then parse it as JSON: json.loads(response.decode('utf-8'))

Error occuring while sending test mail using flask-mail

I am basically building a flask web app which takes codeforces user id and returns user info
i am trying to add flask-mail functionality into it but it displays the
error:
TypeError: cannot unpack non-iterable NoneType object
The error is in the mail.send(msg) line
from flask import Flask, render_template,redirect,request
from flask_mail import Mail,Message
import requests
import json
import os
app = Flask(__name__)
app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = 'testdev582#gmail.com'
app.config['MAIL_PASSWORD'] = 'hardik1234'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
#print(app.config.update(mail_settings))
#app.config.update(mail_settings)
mail = Mail(app)
#app.route('/',methods=['GET','POST'])
def index():
if request.method == 'POST':
username = request.form['username']
email_id = request.form.get('email-id')
msg = Message("test",sender=app.config.get("MAIL_USERNAME"),recipients=[email_id])
mail.send(msg)
print(email_id)
#print(username)
url = 'http://codeforces.com/api/user.info?handles=' + username
wvurl = 'http://codeforces.com/api/contest.list?gym=false'
resp = requests.get(url)
r = requests.get(wvurl)
if resp and r:
user_data = json.loads(resp.text)['result']
contest_data = json.loads(r.text)['result']
for contest in contest_data:
if contest['phase'] == 'BEFORE':
break
print(contest['name'])
return render_template('show.html',user_data = user_data,contest_data = contest)
else:
print("Error in getting response")
return render_template('index.html')
return render_template('index.html')
if __name__=='__main__':
app.run(debug=True)

You will want to use os.environ
example:
app.config['MAIL_USERNAME'] = os.environ.get('EMAIL_USER', 'my#email.com')
app.config['MAIL_PASSWORD'] = os.environ.get('EMAIL_PASS', 'mypassword')
or set environment variables
windows:
https://www.youtube.com/watch?v=IolxqkL7cD8
linux:
https://www.youtube.com/watch?v=5iWhQWVXosU

You can try to check email_id if it is wrong.
I was just wrong there.

How to handle multiple WSGI applications in Flask?

I'm a newbie in Flask and was wondering how to implement Flask API (http://www.flaskapi.org/) along with the main website, for example, main website (/), access API (/api/). In fact, this gives me an Internal Server Error.
Thank you.
from flask import Flask, request, url_for
from flask.ext.api import FlaskAPI, status, exceptions
# the all-important app variable:
app = Flask(__name__)
app2 = FlaskAPI(__name__)
#app.route("/")
def hello():
return "Oh, Hello Worldaa"
notes = {
0: 'do the shopping',
1: 'build the codez',
2: 'paint the door',
}
def note_repr(key):
return {
'url': request.host_url.rstrip('/api/') + url_for('notes_detail', key=key),
'text': notes[key]
}
#app2.route("/api/", methods=['GET', 'POST'])
def notes_list():
"""
List or create notes.
"""
if request.method == 'POST':
note = str(request.data.get('text', ''))
idx = max(notes.keys()) + 1
notes[idx] = note
return note_repr(idx), status.HTTP_201_CREATED
# request.method == 'GET'
return [note_repr(idx) for idx in sorted(notes.keys())]
#app2.route("/api/<int:key>/", methods=['GET', 'PUT', 'DELETE'])
def notes_detail(key):
"""
Retrieve, update or delete note instances.
"""
if request.method == 'PUT':
note = str(request.data.get('text', ''))
notes[key] = note
return note_repr(key)
elif request.method == 'DELETE':
notes.pop(key, None)
return '', status.HTTP_204_NO_CONTENT
# request.method == 'GET'
if key not in notes:
raise exceptions.NotFound()
return note_repr(key)
if __name__ == "__main__":
app.run(debug=True)
app2.run(debug=True)

You can look at Blueprint in the documentation of Flask.
For example:
main = Blueprint(__name__)
#main.route("/")
def index():
return "Hello, World."
api = Blurprint(__name__)
#api.route("/test")
def test():
return jsonify(dict(test="test")})
app = Flask(__name__)
app.register_blueprint(main)
app.register_blueprint(api, url_prefix="/api")
and then, you access index page by http://example.com, access api by http://example.com/api/test