def tearDown(self):
foobar_user = db_session_users.query(User).filter_by(
email="*****@*****.**").first()
if foobar_user:
db_session_users.query(UserAgency).filter_by(
user_id=foobar_user.id).delete()
db_session_users.commit()
db_session_users.delete(foobar_user)
db_session_users.commit()
def test_success(self):
email = '*****@*****.**'
with patch("requests.post") as rpost:
mock_response = rpost.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"access_token": "doesntmatter"}
with patch("requests.get") as rget:
mock_response = rget.return_value
mock_response.status_code = 200
mock_response.json.return_value = {
"firstName": "doesntmatter",
"lastName": "doesntmatter",
"id": "doesntmatter",
"emailAddress": email
}
req_body = {'code': 'doesntmatter', "redirect_uri": "doesntmatter", 'termsAgreed': 'true'}
resp = self.client.post("/auth_linkedin_token", data=req_body)
user = db_session_users.query(User).filter_by(email=email).first()
self.assert200(resp)
self.assertIn("jwt_token", resp.data)
self.assertIn('confirmed_date', user.properties)
self.assertIn('linkedin_data', user.properties)
self.assertIsInstance(user.properties['confirmed_date'], basestring)
self.assertEqual(True, user.enabled)
def test_google_success(self):
with patch("requests.post") as rpost:
mock_response = rpost.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"access_token": "doesntmatter"}
email = "*****@*****.**"
with patch("requests.get") as rget:
mock_response = rget.return_value
mock_response.status_code = 200
mock_response.json.return_value = {
"given_name": "doesntmatter",
"family_name": "doesntmatter",
"id": "doesntmatter",
"email": email
}
req_body = {
'code': 'doesntmatter',
"redirect_uri": "doesntmatter",
'termsAgreed': 'true'
}
resp = self.client.post("/auth_google_token", data=req_body)
user = db_session_users.query(User).filter_by(email=email).first()
self.assert200(resp)
self.assertIn("jwt_token", resp.data)
self.assertIn('confirmed_date', user.properties)
self.assertIsInstance(user.properties['confirmed_date'], basestring)
self.assertEqual(True, user.enabled)
def test_success_link_to_email_account(self):
email = "*****@*****.**"
db_session_users.add(
User({
'email': email,
'password': '******',
'enabled': False
}))
db_session_users.commit()
initial_user = db_session_users.query(User).filter_by(
email=email).first()
with patch("requests.post") as rpost:
mock_response = rpost.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"access_token": "doesntmatter"}
with patch("requests.get") as rget:
mock_response = rget.return_value
mock_response.status_code = 200
mock_response.json.return_value = {
"given_name": "doesntmatter",
"family_name": "doesntmatter",
"id": "doesntmatter",
"email": email
}
req_body = {
'code': 'doesntmatter',
"redirect_uri": "doesntmatter",
'termsAgreed': 'true'
}
resp = self.client.post("/auth_google_token", data=req_body)
updated_user = db_session_users.query(User).filter_by(
email=email).first()
self.assert200(resp)
self.assertIn("jwt_token", resp.data)
self.assertIn('confirmed_date', updated_user.properties)
self.assertIsInstance(updated_user.properties['confirmed_date'],
basestring)
self.assertEqual(True, updated_user.enabled)
self.assertEqual(True, len(updated_user.google_id) > 0)
self.assertIn('secondary_signup_dates', updated_user.properties)
self.assertIn('google',
updated_user.properties['secondary_signup_dates'])
self.assertIsInstance(
updated_user.properties['secondary_signup_dates']['google'],
basestring)
def test_pop_judgment_with_empty_queue(self):
# hack: change the status of everything on the queue to something that won't be popped to
# simulate an empty queue scenario
for tj in db_session_users.query(TopicJudgment).all():
tj.status = 'skipped'
db_session_users.add(tj)
db_session_users.commit()
response = self.client.get("/topic_judgments/pop", headers={'Authorization': self.token})
self.assert200(response)
for key in ['id', 'status', 'judgment', 'document', 'user', 'topic_name']:
self.assertNotIn(key, response.json)
self.assertIn('queue', response.json)
self.assertEqual(response.json['queue'], 'empty')
def test_update_judgment(self):
topic_judgment = db_session_users.query(TopicJudgment).first()
request_body = json.dumps({
'status': 'judged',
'judgment': True
})
response = self.client.post("/topic_judgments/"+str(topic_judgment.id), headers={'Authorization': self.token}, data=request_body)
self.assert200(response)
for key in ['id', 'status', 'judgment', 'topic_id', 'topic_name', 'doc_id', 'user_id']:
self.assertIn(key, response.json)
# make sure it is tagged as judged, judgment=True, and the user_id is set
self.assertEqual(response.json['status'], 'judged')
self.assertEqual(response.json['user_id'], self.user.id)
self.assertEqual(response.json['judgment'], True)
def test_pop_judgment_with_zz_bad_doc(self):
# hack: change the status back for everything to queued and set all but one doc to an invalid doc id
original_tj = db_session_users.query(TopicJudgment).first()
bad_tj = TopicJudgment(original_tj.__dict__)
bad_tj.doc_id = 1000000
bad_tj.status = 'queued'
bad_tj.user_id = self.new_user.id
db_session_users.add(bad_tj)
db_session_users.commit()
response = self.client.get("/topic_judgments/pop", headers={'Authorization': self.new_user_token})
self.assert200(response)\
#n.b. the previous test left this in the state where everything else is queued
for key in ['id', 'status', 'judgment', 'document', 'user', 'topic_name']:
self.assertNotIn(key, response.json)
self.assertIn('queue', response.json)
self.assertEqual(response.json['queue'], 'empty')
def test_reset_disabled_user(self):
user = factories.UserFactory.build(
first_name=None,
last_name=None,
)
user.enabled = False
user.gen_reset_token()
db_session_users.add(user)
db_session_users.flush()
db_session_users.refresh(user)
req_body = {
'email': user.email,
}
resp = self.client.post(
"/reset",
data=json.dumps(req_body),
)
self.assert200(resp)
updated_user = db_session_users.query(User).filter_by(email=user.email).first()
self.assertEqual(user.reset_token, updated_user.reset_token)
import os
import sys
import jwt
import requests
import random
import datetime as dt
this_folder = os.path.dirname(os.path.realpath(__file__))
sys.path.append(this_folder + '/../')
from shared_env import *
from settings import SECRET_JWT
from schemas import base_users
from models import *
from app import app, db_session_users
from schemas import jurasticsearch as jsearch
this_folder = os.path.dirname(os.path.realpath(__file__))
# create a token to use for authorization for all api calls
user = db_session_users.query(User).filter_by(id=1).scalar()
seconds_until_expiration = 60 * 60 * 24 * 14
expiration_datetime = dt.datetime.utcnow() + dt.timedelta(seconds=seconds_until_expiration)
token = jwt.encode({'user_id': user.id, 'exp': expiration_datetime}, SECRET_JWT)
print token
def test_login(self):
user = factories.UserFactory.build(
first_name=None,
last_name=None,
)
user.enabled = False
db_session_users.add(user)
db_session_users.flush()
db_session_users.refresh(user)
# test with a disabled account
req_body = {
'email': user.email,
'password': '******',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
# test that proper error message is sent back, in the case a user is not from a campaign
# but has signed-up with open registration so the msg must contain the term `verified`
user_part_of_campaign = db_session_users.query(
MarketingCampaignUsers).filter_by(id=user.id).first()
if user_part_of_campaign or "invited_by" not in user.properties:
self.assertRegexpMatches(resp.json['error'], r'verified')
# invite a random user
req_body = json.dumps({'email': '*****@*****.**'})
resp = self.client.post(
"/invite",
headers={'Authorization': self.admin_user_token},
data=req_body)
self.assert200(resp)
new_user = db_session_users.query(User).filter_by(
email='*****@*****.**').first()
self.assertFalse(new_user.enabled)
# then have the user login before becoming enabled
req_body = {
'email': '*****@*****.**',
'password': '******',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
# test that proper error message is sent out, in the case a user is neither from a campaign
# nor has signed-up with open registration, but has been invited so the msg must contain the term `enabled`
self.assertRegexpMatches(resp.json['error'], r'enabled')
# enable but don't set password
user.enabled = True
db_session_users.add(user)
db_session_users.flush()
db_session_users.refresh(user)
req_body = {
'email': user.email,
'password': '',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
self.assert400(resp)
# set a password and login
user.update_password('foo')
db_session_users.add(user)
db_session_users.flush()
db_session_users.refresh(user)
req_body = {
'email': user.email,
'password': '******',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
self.assert200(resp)
# make sure bad password is rejected
req_body = {
'email': user.email,
'password': '******',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
self.assert401(resp)
# now suspend the user and make sure it fails
user.suspended = True
db_session_users.add(user)
db_session_users.flush()
db_session_users.refresh(user)
req_body = {
'email': user.email,
'password': '******',
}
resp = self.client.post(
"/login",
data=json.dumps(req_body),
)
self.assert401(resp)
from models import *
from app import app, db_session_users
from schemas import jurasticsearch as jsearch
this_folder = os.path.dirname(os.path.realpath(__file__))
BuildName = jsearch.ACTIVE_INDEX_NAME
SearchVersion = 1
## NB: tweak by hand for now
## koala-0 = javelina
## koala-1 = acronym boost (boost=8.0)
# create a token to use for authorization for all api calls
user = db_session_users.query(User).filter_by(id=1).scalar()
seconds_until_expiration = 60 * 60 * 24 * 14
expiration_datetime = dt.datetime.utcnow() + dt.timedelta(seconds=seconds_until_expiration)
token = jwt.encode({'user_id': user.id, 'exp': expiration_datetime}, SECRET_JWT)
for q in db_session_users.query(SearchRegressionQuery).all():
url = "http://localhost:5000/documents?query={}".format(q.query)
response = requests.get(url, headers={'Authorization': token})
docs = response.json()['documents']
doc_ids = [ d['id'] for d in docs ]
scores = [ d['score'] for d in docs ]
results = { 'documents': docs }
assessment_params = {
'query_id': q.id,
'build': BuildName,
'version': SearchVersion,
def search_results(query_id, side='reference'):
return db_session_users.query(SearchAssessmentResult).filter_by(
query_id=query_id, build=BuildName[side], version=SearchVersion[side]).scalar()
from app import app, db_session_users
from schemas import jurasticsearch as jsearch
reload(sys)
sys.setdefaultencoding('utf8')
BuildName = { 'reference': 'koala', 'hypothesis': 'koala' }
SearchVersion = { 'reference': 0, 'hypothesis': 1 }
def search_engine_name(side='reference'):
return "{}-{}".format(BuildName[side], SearchVersion[side])
HypothesisName = search_engine_name('hypothesis')
ReferenceName = search_engine_name('reference')
QueryText = { q.id:q.query for q in db_session_users.query(SearchRegressionQuery).all() }
def search_results(query_id, side='reference'):
return db_session_users.query(SearchAssessmentResult).filter_by(
query_id=query_id, build=BuildName[side], version=SearchVersion[side]).scalar()
def average_score(scores):
if scores:
return round(reduce(lambda x, y: x + y, scores) / len(scores), 4)
else:
return 0.0
def result_list(doc_ids, docs):
result = ''
for d in docs:
if d['id'] in doc_ids:
def build_query_set():
for line in open(this_folder + '/fixtures/relevance_queries.tsv'):
query = line.strip().split("\t")[1]
if not db_session_users.query(SearchRegressionQuery).filter_by(query=query).scalar():
db_session_users.add(SearchRegressionQuery({ 'query': query}))
db_session_users.commit()
from models import *
from app import app, db_session_users
from schemas import jurasticsearch as jsearch
this_folder = os.path.dirname(os.path.realpath(__file__))
## NB: For converting a raw list of queries to id,query tsv (already run)
#cur_id = 52
#for line in open(this_folder + '/fixtures/relevance_queries.tsv'):
# line = line.strip()
# print "{}\t{}".format(cur_id, line)
# cur_id += 1
# create a token to use for authorization for all api calls
user = db_session_users.query(User).filter_by(id=1).scalar()
seconds_until_expiration = 60 * 60 * 24 * 14
expiration_datetime = dt.datetime.utcnow() + dt.timedelta(seconds=seconds_until_expiration)
token = jwt.encode({'user_id': user.id, 'exp': expiration_datetime}, SECRET_JWT)
test_set = [ ]
## TODO: persist, then pull from persistent resource
## TODO: make sure the resource can store eval results
for line in open(this_folder + '/fixtures/relevance_queries.tsv'):
#print line
line = line.strip()
cols = line.split("\t")
query = { 'query': cols[1], 'id': cols[0], 'type': 'search query' }
test_set.append(query)
