def ALoginUser():
#POST/PUT parameters
params = request.get_json()
print "PARAMS", params
user = User(params)
print "USER", user
results = [ {'label':'/VHome', 'msg':[], "actor": user.user },
{'label':'/user/login', 'msg':[ur'Error al iniciar sesión']}, ]
if user.authenticate():
res = results[0]
else:
res = results[1]
#Action code ends here
if "actor" in res:
if res['actor'] is None:
session.pop("actor", None)
else:
session['actor'] = res['actor']
return json.dumps(res)
def create_user():
input_data = json.loads(request.data)
user = User()
if (user.create(input_data) is False):
abort(401)
return jsonify(user.data), 201
def validate(self, data):
# Grant Flow: "Resource Owner Password Credentials Grant"
response = utils.validate_body([u'username', u'password'], data)
if (response):
return response
else:
#FIXME filter input
username = data['username']
password = data['password']
user = User()
# validate credentials username and password
if (user.validate_credentials(username, password) is True):
# TODO generate a token and store it with user
data = {
'access_token' : '42374690y41yd0BXC.df-7629013eo',
'token_type' : 'Bearer',
'expires_in' : '3600'
}
#in debug
data['uid'] = user.get_uid_with(username)
return utils.response_with(data, 200)
else:
data = {'error': 'invalid_grant'}
# in debug
data['error_description'] = 'invalid password credentials'
return utils.response_with(data, 400)
def VListUsers():
params = request.args
print request.args
eventid = params.get('requestedUser')
print eventid
by_event = False
owner = None
if eventid is None:
users = User.all()
else:
users = User.from_event(eventid)
owner = Event.get_owner(eventid)
by_event = True
res = { 'users' : users }
res['actor'] = None
res['by_event'] = by_event
res['owner'] = owner
if "actor" in session:
res['actor']=session['actor']
#Action code goes here, res should be a JSON structure
#Action code ends here
return json.dumps(res)
def test_create(self):
user = yield User.create({'username': '******', 'password': '******'})
self.assertTrue(user.id)
cursor = User.find({'_id': user.id})
def each_callback(result, error):
self.assertFalse(error)
cursor.each(callback=each_callback)
def user():
u = User()
u.id = 2
u.name = 'Bob'
UserFactory.USERS.append(u.__dict__)
return u
def _on_login(self, user):
try:
c_user = User.objects(access_token=user['access_token']).get()
except DoesNotExist, e:
c_user = User()
c_user.access_token = user["access_token"]
cb = functools.partial(self._save_user_profile, c_user)
self.facebook_request("/me", access_token=c_user.access_token, callback=cb)
cb = functools.partial(self._save_user_friends, c_user)
self.facebook_request("/me/friends", access_token=c_user.access_token, callback=cb, fields='first_name,last_name,id,picture')
def test_save(self):
user = User({'username': '******', 'password': '******'})
self.assertEqual(user.is_inserted, False)
yield user.save()
self.assertEqual(user.is_inserted, True)
self.assertTrue(user.id)
user.username = '******'
yield user.save()
yield user.save()
yield user.remove()
return None
def fetch():
phone_number = request.args.get('phone_number')
query = User.query()
if phone_number:
query = User.query(User.phone_number == phone_number)
users = query.order(-User.ts_created).fetch()
return {
'users': [u.to_dict() for u in users] if users else []
}
def on_get(self):
uid = self.current_user.id
u = User.objects(id=uid).get()
stats = u.get_user_stats()
progress = u.get_overall_progress()
self.base_render("dashboard.html", user=u,
progress = progress,
stats= stats)
def on_get(self):
if not self.current_user:
self.base_render("home.html")
else:
uid = self.current_user.id
u = User.objects(id=uid).get()
history = MockTest.objects(user=str(uid)) #TODO: create a model for user's history
self.redirect("/dashboard")
def test_insert_without_name(self):
res = self.insert(role='farmer', phone_number='1234567')
data = json.loads(res.data)
self.assertEqual(400, res.status_code)
self.assertEqual('first_name is required', data['error'])
self.assertEqual(0, len(User.query().fetch()))
def VShowUser():
print request
userId = request.args.get('user')
res = {}
if userId is not None:
res['user'] = User.get(userId)
res['created_event'] = User.get_created(userId)
res['assisted_event'] = User.get_assisted(userId)
if "actor" in session:
res['actor']=session['actor']
#Action code goes here, res should be a JSON structure
#Action code ends here
return json.dumps(res)
def test_with_different_roles(self):
self.insert(role='farmer', phone_number='1234567',
first_name='Kat', last_name='Leigh',
district_id=self.district.key.id())
self.insert(role='hutan_biru', phone_number='1234567',
first_name='Kat', last_name='Leigh')
self.assertEqual(2, len(User.query().fetch()))
def test_insert_with_undefined_roles(self):
res = self.insert(role='teacher', phone_number='1234567',
first_name='Kat')
data = json.loads(res.data)
self.assertEqual(400, res.status_code)
self.assertTrue('teacher is an invalid role' in data['error'])
self.assertEqual(0, len(User.query().fetch()))
def add_test_user():
session = get_db_session()
user = session.query(User).filter_by(username='******').first()
if not user:
user = User(username='******',
realname="realname_test",
email="*****@*****.**",
password="******")
session.add(user)
session.commit()
def test_broadcast(self):
# add farmers
User(role='farmer',
phone_number='123',
first_name='farmer1',
district_id='sum123').put()
res = self.send('broadcast hello world')
self.assertIn(_('Message delivered'), res.data)
def register():
form = RegisterForm()
if request.method == "POST":
if not form.validate():
return Response(json.dumps({'code': 0, 'msg': form.get_first_error()}), content_type='application/json')
if not session['verify_code'].lower() == form.VerifyCode.data.lower():
return Response(json.dumps({'code': 0, 'msg': "验证码不正确"}), content_type='application/json')
if not session[form.Email.data].lower() == form.SmsCode.data.lower():
return Response(json.dumps({'code': 0, 'msg': "邮箱验证码不正确"}), content_type='application/json')
user = User.query.filter_by(email=form.Email.data).first()
if user is not None:
return Response(json.dumps({'code': 0, 'msg': "用户已经存在"}), content_type='application/json')
else:
new_user = User(name=form.Name.data, password=form.Password.data,
email=form.Email.data)
new_user.add_one()
login_user(new_user)
session.pop(form.Email.data)
return Response(json.dumps({'code': 1, 'msg': '注册成功'}), content_type='application/json')
def login():
if request.method == 'POST':
username = request.form.get('username')
print(username)
user = query_user(username)
if user is not None and request.form['password'] == user['password']:
curr_user = User()
curr_user.id = username
login_user(curr_user, remember=True)
next = request.args.get('next')
#return redirect(next or url_for('bp_views.index'))
#return redirect(url_for('bp_eth.eth'))
return render_template('index.html')
flash('wrong username or password !!!')
#return render_template('login.html')
return render_template('index.html')
def create_user(user_name, email, password, role_id, department_id):
user = User(id=str(uuid.uuid4()), name=user_name, email=email)
pw = Password(user_id=user.id, password=password)
profile = UserProfile(user_id=user.id,
role_id=role_id,
department_id=department_id)
db.session.add(user)
db.session.add(pw)
db.session.add(profile)
db.session.commit()
def test_insert_with_undefined_roles(self):
res = self.insert(role='teacher',
phone_number='1234567',
first_name='Kat')
data = json.loads(res.data)
self.assertEqual(400, res.status_code)
self.assertTrue('teacher is an invalid role' in data['error'])
self.assertEqual(0, len(User.query().fetch()))
def test_handle_delete_not_admin(self):
"""Test team command delete parser with improper permission."""
team = Team("BRS", "brs", "web")
test_user = User("userid")
self.db.retrieve.return_value = test_user
self.db.query.return_value = [team]
self.assertTupleEqual(self.testcommand.handle("team delete brs", user),
(self.testcommand.permission_error, 200))
self.db.delete.assert_not_called()
self.gh.org_delete_team.assert_not_called()
def construct_user(self, email="*****@*****.**", role=Role.user):
db_user = db.session.query(User).filter_by(email=email).first()
if db_user:
return db_user
user = User(email=email, role=role)
db.session.add(user)
db_user = db.session.query(User).filter_by(email=user.email).first()
self.assertEqual(db_user.email, user.email)
return db_user
def forget_password(token):
form = ResetPasswordForm(request.form)
if form.validate():
success = User.reset_password(token, form.password1.data)
if success:
send_log('/v1/auth/reset/password/')
return jsonify({"code": 200})
else:
send_log('/v1/auth/reset/password/')
return jsonify({"code": -1, "errMsg": "密码修改失败"})
def add_user(user_name, password):
session = Session()
user = session.query(User).filter_by(user_name=user_name).first()
if not user:
user = User(user_name, password)
session.add(user)
session.commit()
return user
else:
return None
def forget_password(token):
form = ResetPasswordForm(request.form)
if request.method == 'POST' and form.validate():
success = User.reset_password(form.password1.data,token)
if success:
flash('你的密码已更新，请使用新密码登录')
return redirect(url_for('web.login'))
else:
flash('密码重置失败')
return render_template('auth/forget_password.html')
def verify_jwt(token):
try:
payload = jwt.decode(token, current_app.config['JWT_SECRET'], algorithm=['HS256'])
if payload['iat'] < time.time():
return None, "登入超时"
user = User.objects(id=payload['id']).first()
if not user:
return None, "无此用户"
return user, ""
except:
return None, "数据错误"
def test_handle_edit_not_admin(self):
"""Test team command edit parser with insufficient permission."""
test_user = User("userid")
team = Team("BRS", "brs", "brS")
self.db.retrieve.return_value = test_user
self.db.query.return_value = [team]
with self.app.app_context():
self.assertTupleEqual(self.testcommand.handle("team "
"edit brs", user),
(self.testcommand.permission_error, 200))
self.db.store.assert_not_called()
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('unique_id', type=str, required=True, nullable=False, location='args')
parsed_args = parser.parse_args()
parent = User.get_user(parsed_args['unique_id'])
if parent is None:
abort(400, code=1001, message={'parent': 'parent does not exist'})
user_list = User.query.filter(User.sponsor_id == parent.id,
User.locked != 2).all()
return user_list
def load_users(self):
with open(self.user_file, newline='') as csvfile:
reader = csv.reader(csvfile, delimiter=csv.excel.delimiter, quotechar=csv.excel.quotechar)
next(reader, None) # skip the headers
for row in reader:
user = User(id=row[0], email=row[1], password=row[2],
role=row[3], email_verified=True)
db.session.add(user)
print("Users loaded. There are now %i users in the database." % db.session.query(
User).count())
db.session.commit()
def incoming_twilio_sms():
sms = SmsRequest(id=SmsRequest.id(),
from_number=request.form.get('From'),
to_number=request.form.get('To'),
body=request.form.get('Body'),
twilio_message_id=request.form.get('MessageSid'),
from_city=request.form.get('FromCity'),
from_state=request.form.get('FromState'),
from_zip=request.form.get('FromZip'),
from_country=request.form.get('FromCountry'),
to_city=request.form.get('ToCity'),
to_state=request.form.get('ToState'),
to_zip=request.form.get('ToZip'),
to_country=request.form.get('ToCountry'))
if not sms.valid:
app.logger.error(request)
abort(400, 'invalid request')
# store all sms for auditing
sms.put()
# load application data associated with the sms
user = User.query(User.phone_number == sms.from_number).fetch()
if not user:
abort(400, 'The phone number {} does not belong to a user'.format(sms.from_number))
sms.user = user[0]
response_twiml = twiml.Response()
response_message = None
# dispatch sms request
try:
response_message = dispatcher.dispatch(sms)
except (NoRouteError, MultipleRouteError):
response_message = _('Unknown command, valid format below:\n'
'PLANT [qty] [type]\n'
'HARVEST [qty] [type]\n'
'SELL [qty] [type]\n'
'BROADCAST [msg]')
if response_message:
config = Config.query().get()
response_twiml.sms(to=sms.from_number,
sender=config.twilio_phone_number,
msg=response_message)
# update sms processed state
sms.processed = True
sms.ts_processed = datetime.now()
sms.put()
return str(response_twiml)
def test_insert_without_auth(self):
res = self.insert_without_auth(role='farmer', phone_number='1234567',
first_name='Kat', last_name='Leigh',
district_id=self.district.key.id())
data = json.loads(res.data)
self.assertEqual(400, res.status_code)
self.assertEqual('unauthorized access', data['error'])
self.assertEqual(0, len(User.query().fetch()))
def create_user():
new_user = User()
new_user.name = request.form.get("name")
new_user.email = request.form.get("email")
new_user.password = request.form.get("password")
new_user.color_id = None
try:
new_user.save()
except IntegrityError:
return Response(status=409)
return Response(status=200)
async def retrieve_current_user2():
user_data = {
"username": '******',
"email": 'user email',
"token": 'user token'
}
user = User(username='******',
email='*****@*****.**',
token='user token')
return JSONResponse(content=jsonable_encoder(user))
def post(self):
try:
id = request.json['id']
pw = request.json['pw']
except Exception as e:
return jsonify({
"message": "need login info",
"exception": str(e)
}), 400
id_check = User.select().where(User.id == id)
pw_check = User.select().where(User.pw == pw)
access_token = create_access_token(identity=id)
refresh_token = create_refresh_token(identity=id)
if id_check.execute() and pw_check.execute():
return jsonify(access_token, refresh_token)
else:
return '로그인 실패', 400
def get_apply_list(clubid, user):
applies = Apply.get_list(clubid)
res = {}
res["applies"] = []
for apply in applies:
user = User.get_user_by_id(apply.userid)
avatar = user.avatar
apply = apply.to_dict()
apply["avatar"] = avatar
res["applies"].append(apply)
return jsonify(res)
def insert():
role = request.form.get('role')
district_id = request.form.get('district_id', None)
if role == User.ROLE_FARMER or role == User.ROLE_DISTRICT_LEADER:
if not district_id:
abort(400, 'district_id is required')
district = District.get_by_id(district_id)
if not district:
abort(400, '{} is an invalid district_id'.format(district_id))
new = User(id=User.id(),
role=role,
district_id=district_id,
phone_number=request.form.get('phone_number'),
first_name=request.form.get('first_name'),
last_name=request.form.get('last_name', None))
new.put()
return new.to_dict()
async def login(user: UserInLogin = Body(..., embed=True),
db: AsyncIOMotorClient = Depends(get_database)):
db_user = await get_user_by_email(db, user.email)
if not db_user or not db_user.check_password(user.password):
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Incorrect email or password")
access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
token = create_access_token(data={"username": db_user.username},
expires_delta=access_token_expires)
return UserInResponse(user=User(**db_user.dict(), token=token))
def get_activity_apply_list(activityid, user):
applies = Apply.get_activity_applies(activityid)
res = {}
res["applies"] = []
for apply in applies:
user = User.get_user_by_id(apply.userid)
avatar = "http://127.0.0.1:5000/static" + user.avatar
apply = apply.to_dict()
apply["avatar"] = avatar
res["applies"].append(apply)
return jsonify(res)
def verify_token(token):
try:
resp = User.decode_auth_token(token)
if resp:
g.user = User.query.filter_by(id=resp).first()
except:
g.user = None
if 'user' in g and g.user:
return True
else:
return False
def test_insert_without_optional_param(self):
res = self.insert(role='hutan_biru', phone_number='1234567',
first_name='Kat')
data = json.loads(res.data)
self.assertEqual('hutan_biru', data['role'])
self.assertEqual('1234567', data['phone_number'])
self.assertEqual('Kat', data['first_name'])
self.assertEqual(None, data['last_name'])
self.assertEqual(1, len(User.query().fetch()))
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.sms = SmsRequest()
self.sms.user = User(role='farmer',
phone_number='6072809193',
first_name='Kat',
district_id='sul123')
self.sms.body = ''
def get_token():
# 验证输入格式
form = UserLoginForm().execute_validate()
# 验证账号，成果即返回{email,scope}
user_info = User.verify(form['email'], form['password'])
expiration = current_app.config['TOKEN_EXPIRATION']
token = generator_token(user_info, expiration)
result = {
'email': user_info['email'],
'token': token.decode('ascii')
}
return jsonify(result)
def register():
form = RegisterForm()
if form.validate_on_submit():
u = User(username=form.username.data,
password=form.password.data)
# 然后保存到数据库中
db.session.add(u)
# 此时还没有提交，所以新用户没有id值，需要手动提交
db.session.commit()
flash('注册成功')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def test_handle_remove_not_admin(self):
"""Test team command remove parser with insufficient permission."""
test_user = User("userid")
team = Team("BRS", "brs", "web")
self.db.retrieve.return_value = test_user
self.db.query.return_value = [team]
with self.app.app_context():
self.assertTupleEqual(self.testcommand.handle("team remove"
" brs ID", user),
(self.testcommand.permission_error, 200))
self.db.store.assert_not_called()
self.gh.remove_team_member.assert_not_called()
def save_to_gifts(isbn):
yushu_book = YuShuBook()
yushu_book.search_by_isbn(isbn)
user_id = g.user.id
if User.can_save_to_list(isbn, user_id):
with db.auto_commit():
gift = Gift()
gift.id = user_id
gift.bookIsbn = yushu_book.books[0]['isbn']
db.session.add(gift)
return Success()
else:
raise NotFound(msg="当前书籍已经加入心愿清单，请不要重复加入")
def post(self):
users = User.objects()
print(users[0].get_user_embedded())
for i in range(len(users)):
current_user = users[i].get_user_embedded()
for j in range(i, len(users)):
user_2 = users[j].get_user_embedded()
list_user = [current_user, user_2]
conversation = Conversation.objects(users=list_user)
conversation = json.loads(conversation.to_json())
if not conversation:
Conversation(users=list_user).save()
return "ok"
def update_base_info(user):
"update gender, username, campus, bio, email"
if request.method == "GET":
print "get method"
data = {
"gender": user.gender,
"username": user.username,
"campus": user.campus,
"bio": user.bio,
"email": user.email,
"avatar_path": "http://127.0.0.1:5000/static" + user.avatar
}
res = {
"status": "ok",
"error": "0",
"message": "success",
"user": data
}
return jsonify(res)
else:
data = request.get_data()
print "on api " + data
jobj = json.loads(data)
user.gender = jobj['gender']
user.email = jobj['email']
user.bio = jobj['bio']
user.username = jobj['username']
user.campus = jobj['campus']
try:
User.update_base_info(user)
except:
res = {"satus": "fail", "error": "1", "message": "服务器错误"}
return jsonify(res)
res = {"status": "ok", "error": "0", "message": "用户信息更新成功"}
print res
return jsonify(res)
def test_handle_edit(self):
"""Test team command edit parser."""
test_user = User("userid")
test_user.permissions_level = Permissions.admin
team = Team("BRS", "brs", "brS")
team.platform = "web"
team_attach = [team.get_attachment()]
team.platform = "iOS"
team.display_name = "b-s"
self.db.retrieve.return_value = test_user
self.db.query.return_value = [team]
with self.app.app_context():
resp, code = self.testcommand.handle("team edit brs "
"--name brS "
"--platform web", user)
expect = {'attachments': team_attach,
'text': 'Team edited: brs, '
'name: brS, '
'platform: web'}
self.assertDictEqual(resp, expect)
self.assertEqual(code, 200)
self.db.store.assert_called_once_with(team)
def ACreateUser():
#POST/PUT parameters
params = request.get_json()
results = [ {'label':'/user/login', 'msg':[ur'Usuario registrado exitosamente']},
{'label':'/user/new', 'msg':[ur'Error al crear usuario']}, ]
user = User(params['data'])
if user.save():
res = results[0]
else:
res = results[1]
#Action code goes here, res should be a list with a label and a message
#Action code ends here
if "actor" in res:
if res['actor'] is None:
session.pop("actor", None)
else:
session['actor'] = res['actor']
return json.dumps(res)
def setUp(self):
self.app = app.test_client()
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.user = User(role="district_leader", phone_number="6072809193", first_name="Kat", district_id="sum123")
self.user.put()
District(id="sum123", name="Sumatra", slug="sumatra").put()
Config(id="test", twilio_phone_number="+321").put()
def setUp(self):
self.app = app.test_client()
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache()
self.user = User(role='farmer', phone_number='+123', first_name='name')
self.user.put()
Config(id='test', twilio_phone_number='+321').put()
def incoming_twilio_sms():
sms = SmsRequest(
id=SmsRequest.id(),
from_number=request.form.get("From"),
to_number=request.form.get("To"),
body=request.form.get("Body"),
twilio_message_id=request.form.get("MessageSid"),
from_city=request.form.get("FromCity"),
from_state=request.form.get("FromState"),
from_zip=request.form.get("FromZip"),
from_country=request.form.get("FromCountry"),
to_city=request.form.get("ToCity"),
to_state=request.form.get("ToState"),
to_zip=request.form.get("ToZip"),
to_country=request.form.get("ToCountry"),
)
if not sms.valid:
app.logger.error(request)
abort(400, "invalid request")
# store all sms for auditing
sms.put()
# load application data associated with the sms
user = User.query(User.phone_number == sms.from_number).fetch()
if not user:
abort(400, "The phone number {} does not belong to a user".format(sms.from_number))
sms.user = user[0]
response_twiml = twiml.Response()
response_message = None
# dispatch sms request
try:
response_message = dispatcher.dispatch(sms)
except (NoRouteError, MultipleRouteError):
response_message = _("Unknown command")
if response_message:
config = Config.query().get()
response_twiml.sms(to=sms.from_number, sender=config.twilio_phone_number, msg=response_message)
# update sms processed state
sms.processed = True
sms.ts_processed = datetime.now()
sms.put()
return str(response_twiml)
def test_insert_user(self):
res = self.insert(role='farmer', phone_number='1234567',
first_name='Kat', last_name='Leigh',
district_id=self.district.key.id())
data = json.loads(res.data)
self.assertEqual('farmer', data['role'])
self.assertEqual('1234567', data['phone_number'])
self.assertEqual('Kat', data['first_name'])
self.assertEqual('Leigh', data['last_name'])
self.assertEqual('district_id', data['district_id'])
self.assertEqual(1, len(User.query().fetch()))
def test_insert_and_retrieve(self):
req = self.insert(role='hutan_biru', phone_number='321',
first_name='Kat', last_name='Leigh')
data = json.loads(req.data)
get = self.retrieve(data['id'])
res = json.loads(get.data)
self.assertEqual(data['id'], res['id'])
self.assertEqual(data['role'], res['role'])
self.assertEqual(data['phone_number'], res['phone_number'])
self.assertEqual(data['first_name'], res['first_name'])
self.assertEqual(data['last_name'], res['last_name'])
self.assertEqual(data['ts_created'], res['ts_created'])
self.assertEqual(data['ts_updated'], res['ts_updated'])
self.assertEqual(1, len(User.query().fetch()))
def ACancelAssitance():
#POST/PUT parameters
user = request.args.get('user')
print "username", user
results = [{'label':'/VListUsers', 'msg':[ur'Asistencia cancelada']}, {'label':'/VListUsers', 'msg':[ur'Error al cancelar asistencia']}, ]
#Action code goes here, res should be a list with a label and a message
if User.cancel_assistance(user):
res = results[0]
else:
res = results[1]
#Action code ends here
if "actor" in res:
if res['actor'] is None:
session.pop("actor", None)
else:
session['actor'] = res['actor']
return json.dumps(res)
class SmsTest(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache()
self.user = User(role='farmer', phone_number='+123', first_name='name')
self.user.put()
Config(id='test', twilio_phone_number='+321').put()
def tearDown(self):
self.testbed.deactivate()
@patch('app.api.sms.main.dispatcher')
def test_request_with_sms_response(self, mock):
mock.dispatch.return_value = 'response message'
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
self.assertEqual(200, res.status_code)
self.assertEqual('<?xml version="1.0" encoding="UTF-8"?>'
'<Response><Sms from="+321" to="+123">'
'response message'
'</Sms></Response>', res.data)
@patch('app.api.sms.main.dispatcher')
def test_request_without_sms_response(self, mock):
mock.dispatch.return_value = None
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
self.assertEqual(200, res.status_code)
self.assertEqual('<?xml version="1.0" encoding="UTF-8"?>'
'<Response />', res.data)
@patch('app.api.sms.main.dispatcher')
def test_request_should_be_logged_in_datastore(self, mock):
mock.dispatch.return_value = None
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
self.assertEqual(200, res.status_code)
all_sms = SmsRequest.query().fetch()
self.assertEqual(1, len(all_sms))
sms = all_sms[0]
self.assertEqual('sid', sms.twilio_message_id)
self.assertTrue(sms.processed)
self.assertEqual(self.user.phone_number, sms.from_number)
self.assertEqual('+321', sms.to_number)
self.assertEqual('jual', sms.body)
@patch('app.api.sms.main.dispatcher')
def test_log_bad_request(self, mock):
mock.dispatch.side_effect = Exception('can not process sms request '
'because of bad action or '
'dispatcher')
with self.assertRaises(Exception):
self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
all_sms = SmsRequest.query().fetch()
self.assertEqual(1, len(all_sms))
sms = all_sms[0]
self.assertEqual('sid', sms.twilio_message_id)
self.assertFalse(sms.processed)
self.assertEqual(self.user.phone_number, sms.from_number)
self.assertEqual('+321', sms.to_number)
self.assertEqual('jual', sms.body)
def test_unknown_from_number(self):
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': '+111',
'To': '+321',
'Body': 'jual'
})
self.assertEqual(400, res.status_code)
self.assertEqual('The phone number +111 does not belong to a user',
json.loads(res.data)['error'])
@patch('app.api.sms.main.dispatcher')
def test_dispatcher_no_route_error(self, mock):
mock.dispatch.side_effect = NoRouteError()
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
# should return an sms response to the user
self.assertEqual(200, res.status_code)
self.assertEqual('<?xml version="1.0" encoding="UTF-8"?>'
'<Response><Sms from="+321" to="+123">'
'{}'
'</Sms></Response>'.format(
_('Unknown command, valid format below:\n'
'PLANT [qty] [type]\n'
'HARVEST [qty] [type]\n'
'SELL [qty] [type]\n'
'BROADCAST [msg]')),
res.data)
@patch('app.api.sms.main.dispatcher')
def test_dispatcher_multiple_route_error(self, mock):
mock.dispatch.side_effect = MultipleRouteError()
res = self.app.post('/v1/sms/twilio', data={
'MessageSid': 'sid',
'From': self.user.phone_number,
'To': '+321',
'Body': 'jual'
})
# should return an sms response to the user
self.assertEqual(200, res.status_code)
self.assertEqual('<?xml version="1.0" encoding="UTF-8"?>'
'<Response><Sms from="+321" to="+123">'
'{}'
'</Sms></Response>'.format(
_('Unknown command, valid format below:\n'
'PLANT [qty] [type]\n'
'HARVEST [qty] [type]\n'
'SELL [qty] [type]\n'
'BROADCAST [msg]')),
res.data)
def get_user(uid):
user = User()
if(user.load(uid) == False):
abort(404)
return jsonify(user.data), 200
def test_cursor_to_list(self):
user = yield User.create({'username': '******', 'password': '******'})
cursor = User.find({'_id': user.id})
users = yield cursor.to_list(1)
self.assertEqual(len(users), 1)
def test_cursor_fetch_next(self):
user = yield User.create({'username': '******', 'password': '******'})
cursor = User.find({'_id': user.id})
yield cursor.fetch_next
self.assertTrue(cursor.next_object())
