def page_contains_content(route, content='Queer Art and P**n Collective'):
# essentially just testing that the page builds at all
client = app.test_client()
page = client.get(route)
data = str(page.data)
pprint.pprint(data)
return content in data
def setUp(self):
self.con = db.conn()
self.app = app.test_client()
self.username = '******'
self.password = '******'
self.username2 = 'testUser2'
self.group_name = 'testGroupName1'
def make_shell():
"""Interactive Flask Shell"""
from flask import request
#from hello import init_db as initdb
app = make_app()
http = app.test_client()
reqctx = app.test_request_context
return locals()
def setUp(self):
self.db_fd, main.app.config['HEAPED_DATABASE_URL'] = tempfile.mkstemp()
app.config['TESTING'] = True
# app.config['CSRF_ENABLED'] = False
# webstart.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db')
# app.config['HEAPED_DATABASE_URL'] = os.environ['HEAPED_DATABASE_URL']
self.app = app.test_client()
db.drop_all()
db.create_all()
def test_love_q2():
with app.test_client() as c:
resp = c.post('/bot', data=dict(user_name='my_username', text='runbotton: love me', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'I will be yours until I die.'}))
resp = c.post('/bot', data=dict(user_name='my_username', text='runbotton: who do you love?', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'I will always love my_username!'}))
resp = c.post('/bot', data=dict(user_name='my_username2', text='runbotton: love me', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': "my_username is dead to me. I'm all about my_username2 now!"}))
def setUp(self):
self.app = app.test_client()
self.comment_data = {
"name": "admin",
"email": "*****@*****.**",
"url": "http://localhost",
"ip_address": "127.0.0.1",
"body": "test comment!",
"entry_id": 1
}
def setUp(self):
app.config['TESTING'] = True
app.config['CSRF_ENABLED'] = False
self.app = app.test_client()
# Setups app engine test bed. See: http://code.google.com/appengine/docs/python/tools/localunittesting.html#Introducing_the_Python_Testing_Utilities
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_user_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.task_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
def setUp(self):
# Flask apps testing. See: http://flask.pocoo.org/docs/testing/
app.config.from_pyfile(os.path.join(config.BASE_DIR, 'config.py'))
self.flask_app = app
self.app = app.test_client()
# Setups app engine test bed.
# See: http://code.google.com/
# appengine/docs/python/tools/localunittesting.html#Introducing_the_Python_Testing_Utilities
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_user_stub()
self.testbed.init_memcache_stub()
def setUp(self):
ndb.get_context().clear_cache()
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
self.app = app.test_client()
self.user_data = {
'email': '*****@*****.**',
'password': '******',
'password_confirm': 'password1',
'first_name': 'John',
'last_name': 'Doe',
'zipcode': '90210'
}
def test_valid_delete(_set_up_client, _reset_limits, _clear_db):
response = create_email_alias()
assert len(VirtualAlias.query.all()) == 1
json_data = json.loads(response.get_data())
email = json_data['email']
client = app.test_client()
timestamp = int(time.time())
token = generate_token(email, timestamp=timestamp)
data = dict(email=email, timestamp=timestamp, token=token)
data = json.dumps(data)
response = client.post('/api/delete',
data=data,
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
assert 'OK' in str(response.data)
assert len(VirtualAlias.query.all()) == 1
assert not VirtualAlias.query.get(1).enabled
def test_exception_handling_from_get_page_count(
self, mocker, test_input_query: dict) -> None:
"""Test other exception handling by get_page_count raises a HTTP 500 status code."""
# Patch the get_page_hash, and get_page_count functions
_ = mocker.patch("main.get_page_hash")
_ = mocker.patch("main.get_page_count", side_effect=Exception())
# Set up the app test client
client = app.test_client()
# Get the /badge page of the app, and assert it returns a HTTP 500 status code
get_client = client.get("/badge",
query_string={
"page": "example",
**test_input_query
})
assert get_client.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
def test_api_get_stat_vars_union(self, send_request):
req = {'dcids': ['geoId/10001', 'geoId/10003', 'geoId/10005']}
result = ["sv1", "sv2", "sv3"]
def side_effect(req_url,
req_json={},
compress=False,
post=True,
has_payload=True):
if (req_url == dc.API_ROOT + "/place/stat-vars/union"
and req_json == req and post and not has_payload):
return {'statVars': {'statVars': result}}
send_request.side_effect = side_effect
response = app.test_client().post('/api/place/stat-vars/union',
json=req)
assert response.status_code == 200
assert json.loads(response.data) == result
def test_retrieve_task_by_id_must_returns_json():
with app.test_client() as client:
import json
response = client.post(
'/tasks',
data=json.dumps(
{
'title': 'The Awesome Title',
'description': 'The Awesome Description'
}
),
content_type='application/json'
)
data = json.loads(response.data.decode('utf-8'))
inserted_id = data['_id']['$oid']
response = client.get('/tasks/%s' % inserted_id)
assert response.content_type == 'application/json'
def test_create_task_returns_created_task():
with app.test_client() as client:
import json
response = client.post(
'/tasks',
data=json.dumps(
{
'title': 'The Best Title',
'description': 'The Best Description'
}
),
content_type='application/json'
)
data = json.loads(response.data.decode('utf-8'))
assert data['title'] == 'The Best Title'
assert data['description'] == 'The Best Description'
assert data['done'] == False
def test_showQuestion(self):
print("\n Enter the id Session")
idSession = input()
print("\n Enter the question number")
numQ = input()
url = '/api/v1/assessment/' + idSession + '/question/' + numQ
print ("\n Loading... \n")
responseDB = lookQuestion(idSession,numQ)
tester = app.test_client(self)
response = tester.get(
url, content_type='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.get_data().decode(sys.getdefaultencoding())), responseDB)
def setUp(self):
"""Set up test environment."""
super(ApisTestCase, self).setUp()
app = create_app()
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['DEBUG'] = False
self.app = app
self.test_client = app.test_client()
self.assertEqual(app.debug, False)
responses.add(responses.GET,
'https://api.github.com/users/BirdOnTheBranch/repos',
json=self.mock_repos,
status=200)
responses.add(responses.GET,
'https://www.codewars.com/api/v1/users/BirdOnTheBranch',
json=self.mock_codewars_stats,
status=200)
def setUpClass(self):
# config app
app.config["TESTING"] = True
self.app = app.test_client()
# config databases
User.client = MongoClient(database_config.TESTING_DATABASE_URL)
User.db = User.client.user
Info.client = MongoClient(database_config.TESTING_DATABASE_URL)
Info.db = Info.client.info
# create user
response = self.register(
self, '_FpCerpd9Z7SIbjmN81Jy_test_profile', '12345678',
'Ognian Baruh', '*****@*****.**')
self.verify(self, '_FpCerpd9Z7SIbjmN81Jy_test_profile')
self.login(self, '_FpCerpd9Z7SIbjmN81Jy_test_profile', '12345678')
def test_addCSV2(self):
with app.test_client() as client:
tupleadd = {
"FName": "Varun",
"LName": "V",
"Math": -45,
"Chem": -81,
"Bio": -94,
"CS": -98,
"Sports": -1
}
response = client.post(
'/api/v1/student',
data=json.dumps(tupleadd),
headers={"Content-Type": "application/json"})
self.assertEqual(response.status_code, 200)
def test_correct_create_channel(self):
weekday = [
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday"
]
tester = app.test_client(self)
tester.post('/login',
data=dict(Username="******", Password="******"),
follow_redirects=True)
response = tester.post('/user_panel',
data=dict(Nickname="admin",
Channel_Name="NewChannel",
Channel_Password="******",
Start_Time="00:01",
End_Time="23:59",
days=",".join(weekday)),
follow_redirects=True)
self.assertIn(b'Leave this channel!', response.data)
print("testing that channel creation is done correctly")
def test_get_page_count_called_correctly(self, mocker,
test_input_page: str,
test_input_query: dict) -> None:
"""Test that get_page_count is called with the correct arguments."""
# Patch the get_page_hash, and get_page_count functions
patch_get_page_hash = mocker.patch("main.get_page_hash")
patch_get_page_count = mocker.patch("main.get_page_count")
# Get the /badge page of the app
_ = app.test_client().get("/badge",
query_string={
"page": test_input_page,
**test_input_query
})
# Assert get_page_count is called correctly
patch_get_page_count.assert_called_once_with(
patch_get_page_hash.return_value[:64])
def test_add_user():
app.config['TESTING'] = True
json_in = {
'name': 'A',
}
with app.test_client() as client:
rv = client.post('/addgroup', json=json_in)
result_data = json.loads(rv.get_data(as_text=True))
group_id = result_data['group_id']
assert db.session.query(Group).count() == 1
user_in = {
'name': "user-A",
'group_id': group_id,
'email': '*****@*****.**'
}
client.post('/adduser', json=user_in)
assert db.session.query(User).count() == 1
def test_request_delete_user_disabled(_set_up_client, _reset_limits,
_clear_db):
response = create_email_alias()
assert len(VirtualAlias.query.all()) == 1
json_data = json.loads(response.get_data())
email = json_data['email']
VirtualAlias.query.get(1).enabled = False
db.session.commit()
assert not VirtualAlias.query.get(1).enabled
client = app.test_client()
data = dict(email=email, )
data = json.dumps(data)
response = client.post('/api/request_delete',
data=data,
content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert 'Email address not found' in str(response.data)
def test_callSession(self):
print("\n Enter the is Session")
idSession = input()
print("\n Enter the tsp")
idTest = input()
url = '/api/v1/assessment/' + idSession + '/' + idTest
print("\n Loading... \n")
responseDB = lookS(idSession)
tester = app.test_client(self)
response = tester.get(url, content_type='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(
json.loads(response.get_data().decode(sys.getdefaultencoding())),
responseDB)
def test_api_parent_places(self, mock_send_request):
mock_send_request.side_effect = self.side_effect
response = app.test_client().get('/api/parent-place/geoId/0649670')
assert response.status_code == 200
assert json.loads(response.data) == [{
"dcid": "geoId/06085",
"name": "Santa Clara County",
"provenanceId": "dc/sm3m2w3",
"types": ["County"]
}, {
"dcid": "geoId/06",
"name": "California",
"provenanceId": "dc/sm3m2w3",
"types": ["State"]
}, {
"dcid": "country/USA",
"name": "United States",
"provenanceId": "dc/sm3m2w3",
"types": ["Country"]
}]
def test_sendAnswers(self):
print("\n Enter the idSession")
idSession = input()
print("\n Enter the Body request")
body = input()
url = '/api/v1/assessment/' + idSession + '/answerAll'
tester = app.test_client(self)
response = tester.post(url, content_type='application/json', data=body)
self.assertEqual(response.status_code, 200)
self.assertEqual(
json.loads(response.get_data().decode(sys.getdefaultencoding())), {
"Status": 1,
"Message": "success",
"Data": True
})
def test_post(self):
tester = app.test_client()
filename = 'test.jpg'
response = tester.post('/api/upload',
content_type='multipart/form-data',
data=dict(file={'file': open(filename, 'rb')},
height='100',
width='100'),
follow_redirects=True)
data = json.loads(response.get_data(as_text=True))
# check if id in response
self.assertIn('id', data)
# check last record id in db == id in reponse
self.assertEqual(
Pictures.query.order_by(Pictures.id.desc()).first().id, data["id"])
# check picture resized
self.assertEqual(
Pictures.query.order_by(Pictures.id.desc()).first().status, 'Done')
# check if everything fine
return self.assertEqual(response.status_code, 200)
def test_home(self):
tester = app.test_client(self)
response = tester.put("/")
self.assertEqual(response.status_code, 405)
response = tester.post("/")
self.assertEqual(response.status_code, 405)
response = tester.delete("/")
self.assertEqual(response.status_code, 405)
response = tester.get("/test_string")
self.assertEqual(response.status_code, 404)
response = tester.get("/")
self.assertEqual(response.status_code, 200)
self.assertIn("keywords", response.json)
self.assertEqual(5, len(response.json["keywords"]))
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(User(id=1, username="******"))
self.db.session.add(
Question(id=1,
title="When is the A1 due?",
content="Is it due this Sunday?",
user_id=1))
self.db.session.add(
Question(id=2,
title="When is the A2 due?",
content="Is it due this Monday?",
user_id=1))
self.db.session.add(
Answer(id=1, content="Yes, It is.", user_id=1, question_id=1))
self.db.session.commit()
self.app = tested_app.test_client()
def setUp(self):
self.client = app.test_client()
self.busObj = Business(1234545543, 'somebusiness', 123132123,
'somelocation', 'somecategory',
'somedescription')
self.client.post('/api/v1/auth/register',
content_type='application/json',
data=json.dumps({
"username": "******",
"password": "******",
"email": "*****@*****.**"
}))
self.client.post('/api/v1/auth/login',
content_type='application/json',
data=json.dumps({
"username": "******",
"password": "******"
}))
def client(request):
test_client = app.test_client()
db = MySQLdb.connect(os.environ['RDS_HOSTNAME'], os.environ['RDS_USERNAME'], os.environ['RDS_PASSWORD'],
os.environ['RDS_DB_NAME'])
cursor = db.cursor(MySQLdb.cursors.DictCursor)
cursor.execute("TRUNCATE TABLE authenticator")
db.commit()
db.close()
def teardown():
db = MySQLdb.connect(os.environ['RDS_HOSTNAME'], os.environ['RDS_USERNAME'], os.environ['RDS_PASSWORD'], os.environ['RDS_DB_NAME'])
cursor = db.cursor(MySQLdb.cursors.DictCursor)
cursor.execute("TRUNCATE TABLE authenticator")
db.commit()
cursor.execute("DELETE FROM user")
db.commit()
db.close()
request.addfinalizer(teardown)
return test_client
def test_with_optional_predicates(self, mock_query):
expected_query = '''
SELECT ?dcid ?mmethod ?obsPeriod
WHERE {
?svObservation typeOf StatVarObservation .
?svObservation variableMeasured test_stat_var .
?svObservation observationAbout geoId/06 .
?svObservation dcid ?dcid .
?svObservation measurementMethod ?mmethod .
?svObservation observationPeriod ?obsPeriod .
?svObservation observationDate "2021" .
}
'''
expected_obs_id = "test_obs_id"
def side_effect(query):
if query == expected_query:
return (['?dcid', '?mmethod', '?obsPeriod', '?obsDate'], [{
'cells': [{
'value': 'obs_id1'
}, {
'value': 'test_mmethod'
}, {}]
}, {
'cells': [{
'value': expected_obs_id
}, {
'value': 'testMethod'
}, {
'value': 'testObsPeriod'
}]
}])
else:
return ([], [])
mock_query.side_effect = side_effect
response = app.test_client().get(
'api/browser/observation-id?statVar=test_stat_var&place=geoId/06&date=2021&measurementMethod=testMethod&obsPeriod=testObsPeriod'
)
assert response.status_code == 200
assert json.loads(response.data) == expected_obs_id
def setUpClass(TestIntegration):
app.testing = True
app.debug = True
app.config['SECRET_KEY'] = 'testing_secret'
TestIntegration.app_client = app.test_client()
with TestIntegration.app_client.session_transaction() as sess:
sess['logged_in'] = 'positive-test-gid'
os.environ['ENV_VAR_FILE_PATH'] = 'static/env.yaml'
with open('static/env.yaml') as y:
env_var = yaml.load(y, Loader=yaml.FullLoader)
TestIntegration.datastore_client = datastore.Client()
TestIntegration.storage_client = storage.Client()
TestIntegration.bucket1 = TestIntegration.storage_client.bucket(
env_var['BUCKET1'])
TestIntegration.bucket2 = TestIntegration.storage_client.bucket(
env_var['BUCKET2'])
img = Image.new('RGB', (512, 512), color='red')
d = ImageDraw.Draw(img)
d.text((100, 100), "Hello World", fill=(255, 255, 0))
byte_arr = io.BytesIO()
img.save(byte_arr, format='PNG')
byte_arr = byte_arr.getvalue()
TestIntegration.app_client.post(
'/',
data={
'file': (io.BytesIO(byte_arr), 'test_integration.png'),
'email': '*****@*****.**',
'gid': 'positive-test-gid'
},
follow_redirects=False,
content_type='multipart/form-data')
sleep(20)
def setUp(self):
# 1. ARRANGE
self.app = app.test_client()
# initialize app with first boardgame
self.app.post('/boardgames',
json={
"name":
"Wingspan",
"designer":
"Elizabeth Hargrave",
"playing_time":
"60 Min",
"rating":
8.1,
"id":
"1",
"expansions": [{
"name": "European Expansion",
"rating": 8.5
}]
})
def test_homepage(self, mock_get_display_name):
mock_get_display_name.return_value = {
'geoId/1150000': 'Washington, DC',
'geoId/3651000': 'New York City, NY',
'geoId/0649670': 'Mountain View, CA',
'geoId/4805000': 'Austin, TX'
}
response = app.test_client().get('/')
assert response.status_code == 200
assert b"Data Commons is an open knowledge repository" in response.data
assert b"July 26, 2021" in response.data
assert b"We have launched exciting new features" in response.data
assert b"Use the Python and REST API's to do your own custom analysis" in response.data
assert b"We cleaned and processed the data so you don't have to" in response.data
assert b"Join the effort." in response.data
assert b"Open sourced" in response.data
assert b"Schema.org" in response.data
assert b"Explore the data" in response.data
assert b"Mountain View, CA" in response.data
assert b"more ..." in response.data
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(City(id=1, city_name="new york", country="us"))
self.db.session.add(City(id=2, city_name="columbus", country="us"))
self.db.session.add(
Team(id=1,
team_name="islanders",
association="east",
division="metropolitan",
city_id=1))
self.db.session.add(
Team(id=2,
team_name="blue jackets",
association="east",
division="metropolitan",
city_id=2))
self.db.session.commit()
self.app = tested_app.test_client()
def test_requests_get_is_called_correctly(self, mocker,
test_input_page: str,
test_input_query: dict) -> None:
"""Test requests.get function is called correctly."""
# Patch the get_page_count, compile_shields_io_url, and requests.get functions
_ = mocker.patch("main.get_page_count")
patch_compile_shields_io_url = mocker.patch(
"main.compile_shields_io_url")
patch_requests_get = mocker.patch("requests.get")
# Get the /badge page of the app
_ = app.test_client().get("/badge",
query_string={
"page": test_input_page,
**test_input_query
})
# Assert requests.get is called with the correct arguments
patch_requests_get.assert_called_once_with(
patch_compile_shields_io_url.return_value)
def test_api_get_places_in_names(self, send_request, display_name):
def send_request_side_effect(req_url,
req_json={},
compress=False,
post=True,
has_payload=True):
if req_url == dc.API_ROOT + "/node/places-in" and req_json == {
'dcids': ['geoId/10'],
'place_type': 'County'
} and not post:
return [{
"dcid": "geoId/10",
"place": "geoId/10001"
}, {
"dcid": "geoId/10",
"place": "geoId/10003"
}, {
"dcid": "geoId/10",
"place": "geoId/10005"
}]
def display_name_side_effect(dcids):
if dcids == "geoId/10001^geoId/10003^geoId/10005":
return {
"geoId/10001": "Kent County, DE",
"geoId/10003": "New Castle County, DE",
"geoId/10005": "Sussex County, DE",
}
send_request.side_effect = send_request_side_effect
display_name.side_effect = display_name_side_effect
response = app.test_client().get(
'/api/place/places-in-names?dcid=geoId/10&placeType=County')
assert response.status_code == 200
assert json.loads(response.data) == {
"geoId/10001": "Kent County, DE",
"geoId/10003": "New Castle County, DE",
"geoId/10005": "Sussex County, DE",
}
def test_api_get_stats_value(self, send_request):
def side_effect(req_url,
req_json={},
compress=False,
post=True,
has_payload=True):
if req_url == dc.API_ROOT + "/stat/value" and req_json == {
'place': 'geoId/06',
'stat_var': 'Count_Person_Male',
'date': None,
'measurement_method': None,
'observation_period': None,
'unit': None,
'scaling_factor': None
} and not post and not has_payload:
return {'value': 19640794}
send_request.side_effect = side_effect
response = app.test_client().get(
'/api/stats/value?place=geoId/06&stat_var=Count_Person_Male')
assert response.status_code == 200
assert json.loads(response.data) == {"value": 19640794}
def test_index(self, mock_fetch_data):
mock_response = {
'geoId/06': {
'in': [{
'dcid': 'dcid1',
'name': 'name1',
'types': ['County', 'AdministrativeArea'],
}, {
'dcid': 'dcid2',
'name': 'name2',
'types': ['County'],
}, {
'dcid': 'dcid3',
'name': 'name3',
'types': ['State'],
}, {
'dcid': 'dcid3',
'name': 'name3',
'types': ['CensusTract'],
}]
}
}
mock_fetch_data.side_effect = (
lambda url, req, compress, post: mock_response)
response = app.test_client().get('/api/place/child/geoId/06')
assert response.status_code == 200
assert json.loads(response.data) == {
'County': [{
'dcid': 'dcid1',
'name': 'name1'
}, {
'dcid': 'dcid2',
'name': 'name2'
}],
'State': [{
'dcid': 'dcid3',
'name': 'name3'
}]
}
def setUp(self):
self.app = app.test_client()
self.db = mock()
def get_fake_db():
return self.db
app.get_db = get_fake_db
def test_love_q():
with app.test_client() as c:
resp = c.post('/bot', data=dict(user_name='my_username', text='runbotton: who do you love?', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'I will always love nobody!'}))
def test_destroy_all():
with app.test_client() as c:
resp = c.post('/bot', data=dict(user_name='my_username', text='runbotton: destroy', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'Launching ICBMs at EVERYBODY.'}))
def setUp(self):
self.app = app.test_client()
self.app.delete("/position") # clean all data
def setUp(self):
app.config['TESTING'] = True
self.client = app.test_client()
def setUp(self):
app.config['TESTING'] = True
app.config['CSRF_ENABLED'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask2'
self.app = app.test_client()
db.create_all()
def setUp(self):
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db')
self.app = app.test_client()
db.create_all()
def client():
""" Instantiate Flask's modified Werkzeug client to use in tests """
app.config["TESTING"] = True
client = app.test_client()
return client
def test_client(self):
app.testing = True
return app.test_client()
def test_redirect_teacher_page_to_login_if_not_soft_logged_in(self):
tester = app.test_client(self)
response = tester.get('teacher/lewlaoshi/home', content_type="html/text")
self.assertEqual(response.status_code, 301)
def test_public_episodes(self):
tester = app.test_client(self)
with app.test_request_context('/lewlaoshi/home?studentID=A9'):
assert request.path == '/lewlaoshi/home'
assert request.args['studentID'] == 'A9'
def setUp(self):
self.driver = webdriver.PhantomJS()
self.driver.set_window_size(1120, 550)
self.tester = app.test_client(self)
def setUp(self):
app.config['TESTING'] = True
app.config['']
app.test_client()
def setUp(self):
app.config['TESTING'] = True
app.config['DEBUG'] = True
self.app = app.test_client()
def testHealthHandler(self):
rv = app.test_client().get('/_ah/health')
assert rv.status == '200 OK'
def setUp(cls):
print('Running setup')
cls.app = app.test_client()
cls.app.testing = True
def setUp(self):
self.db_fd, self.db_file = tempfile.mkstemp()
app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///" + self.db_file
self.app = app.test_client()
with app.app_context():
database.init_db()
def setUp(self):
self.app = app.test_client()
def test_hello():
with app.test_client() as c:
resp = c.post('/bot', data=dict(user_name='my_username', text='runbotton: hi', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'Hello, my_username'}))
def setUp(self):
self.client = my_app.test_client()
def test_kyle():
with app.test_client() as c:
resp = c.post('/bot', data=dict(user_name='19letterslong', text='runbotton: hi', trigger_word='runbotton:'))
h.assert_that(json.loads(resp.data), h.equal_to({'text': 'Kiss off, twit!'}))
