def setUp(self):
with APP.app_context():
self.app = APP.test_client()
self.request_headers = RequestHeaders(
{'Authorization': 'Bearer ' + AuthToken.generate('testsource')})
self.log_file = 'test/fixtures/example-1.log'
self.log_data = open(self.log_file, 'rb').read()
def inner(*args, **kwargs):
# Default HTTP return code
returned_code_value = 444
returned_data = ""
try:
# Getting the returned value
returned_code_value, returned_data = func(*args, **kwargs)
except TypeError as err:
print("Error when processing function: {msg}".format(msg=err))
if not returned_data:
return APP.response_class(
response=json.dumps("NO DATA TO RETURN"),
status=406,
mimetype='application/json')
if not isinstance(returned_data, dict):
response = APP.response_class(
response=json.dumps("DATA CASTING ERROR"),
status=406,
mimetype='application/json')
else:
response = APP.response_class(
response=json.dumps(returned_data),
status=returned_code_value,
mimetype='application/json')
# Returning the value to the original frame
return response
def setUp(self):
with APP.app_context():
self.app = APP.test_client()
self.request_headers = RequestHeaders({
'Authorization':
'Bearer ' + AuthToken.generate('testsource')
})
def run(self):
from app import APP
APP.Functions.set_process_name ( "0@TFTPD" )
logger = APP.LoggingClient ( name="TFTPD" )
controller = APP.Controller( APP.BE.CONTROLLER.tftpd )
logger ( "Initializing the server." )
server_process = Process ( name="TFTPD_LISTEN", target=ProvisioningTFTPServer )
server_process.start()
while True:
action = APP.ControllerWait ( controller )
if action == "STOP": break
logger ("Terminating the server.")
os.kill ( server_process.pid, signal.SIGHUP )
logger ("Waiting for all children to exit.")
server_process.join()
logger ( "Finished." )
#config = ProvCon.Configuration()
#TFTPD = pcTFTPD()
#time.sleep(2)
#ProvCon.ControllerAction ( config.get ( "CONTROLLER", "tftpd"), "STOP" )
#TFTPD.join()
def setUp(self):
APP.config['TESTING'] = True
APP.config['DEBUG'] = False
APP.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/transport_test'
self.app = APP.test_client()
DB.drop_all()
DB.create_all()
self.lifegoup1 = {
'name': 'uq1',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup2 = {
'name': 'uq2',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup3 = {
'name': 'uq3',
'password': '******',
'email': '*****@*****.**'
}
DB.session.add(LifegroupModel(**self.lifegoup1))
DB.session.add(LifegroupModel(**self.lifegoup2))
DB.session.add(LifegroupModel(**self.lifegoup3))
DB.session.commit()
self.member1 = {
'id': '1',
'lifegroup': 'uq1',
'name': 'Kenneth Guo',
'suburb': 'Sunnybank QLD, 4109'
}
self.member2 = {
'id': '2',
'lifegroup': 'uq2',
'name': 'Ken Guo',
'suburb': 'Sunnybank QLD, 4109'
}
self.note1 = {
'id': '1',
'lifegroup': 'uq1',
'text': "A and B stay at the same place"
}
self.note2 = {
'id': '2',
'lifegroup': 'uq2',
'text': "C and D stay at the same place"
}
DB.session.add(MemberModel(**self.member1))
DB.session.add(MemberModel(**self.member2))
DB.session.add(NoteModel(**self.note1))
DB.session.add(NoteModel(**self.note2))
DB.session.commit()
self.assertFalse(APP.debug)
def socketio_test1():
""" Tests to see if server adds users properly """
# log the user in through Flask test client
flask_test_client = APP.test_client()
# connect to Socket.IO without being logged in
socketio_test_client = SOCKETIO.test_client(
APP, flask_test_client=flask_test_client)
# makes a connection to the client
assert socketio_test_client.is_connected()
#test data to see if function works
data = {'joined': 'test'}
#go through on connection to get your logged in player
result1 = on_connection1(data)
#tests adding second player
data2 = {'joined': 'test2'}
result2 = on_connection1(data2)
#tests adding spectator
data3 = {'joined': 'test3'}
result3 = on_connection1(data3)
print(result1, result2, result3)
"""we could see that it runs through th function put's test3 as a spectator
and returns the login list of current added players"""
assert result1 == result2
assert not result1[0] == result2[1]
assert not result3[2] == result2[1]
assert not result3[2] == result1[0]
def test_positive_route_company(self):
"""Verify that the API works for company employees."""
tester = APP.test_client(self)
response = tester.get(
"/paranuara/company/COWTOWN", content_type="application/json"
)
self.assertEqual(response.status_code, 200)
def setUp(self):
'''
Sets up the 'app.py' fixture
'''
self.middleware = []
self.test_app = TestApp(APP.wsgifunc(*self.middleware))
session.set_up(self.test_app)
def test_negative_route_person(self):
"""Verify that the API returns error on wrong link for person favorite fruits and vegetables."""
tester = APP.test_client(self)
response = tester.get(
"paranuara/persON/Decker%20Mckenzie", content_type="application/json"
)
self.assertNotEqual(response.status_code, 200)
def test_negative_route_company(self):
"""Verify that the API returns error on wrong link for company employees."""
tester = APP.test_client(self)
response = tester.get(
"/paranuara/companIES/COWTOWN", content_type="application/json"
)
self.assertNotEqual(response.status_code, 200)
def test_positive_route_person(self):
"""Verify that the API works for person favorite fruits and vegetables."""
tester = APP.test_client(self)
response = tester.get(
"/paranuara/person/Decker%20Mckenzie", content_type="application/json"
)
self.assertEqual(response.status_code, 200)
def test_get_all_request(self):
"""test get all requests"""
tester = APP.test_client(self)
response = tester.get('/api/v1/users/requests',
content_type='application/json')
self.assertEqual(response.status_code, 200)
def test_request_a_ride(self):
"""test to request a ride"""
tester = APP.test_client(self)
info = dict(rideID=4)
response = tester.post('/v1/ride/4/request', data=json.dumps(info),
content_type="application/json")
self.assertEqual(response.status_code, 200)
def setUp(self):
APP.config['TESTING'] = True
APP.config['WTF_CSRF_ENABLED'] = False
self.app = APP.test_client()
DB.Prod.delete_many({})
DB.Logs.delete_many({})
DB.User.insert_one({
'name': 'Alice',
'email': '*****@*****.**',
'password': '******',
'age': 22
})
DB.User.insert_one({
'name': 'Bob',
'email': '*****@*****.**',
'password': '******',
'age': 22
})
DB.User.insert_one({
'name': 'Charlie',
'email': '*****@*****.**',
'password': '******',
'age': 22
})
DB.Session.insert_one({
'session_id': 'abcdefghijklmnopqrstuvwyzabcdef',
'email': '*****@*****.**'
})
def setUp(self):
APP.config['TESTING'] = True
APP.config['WTF_CSRF_ENABLED'] = False
self.app = APP.test_client()
DB.Logs.delete_many({})
DB.Session.insert_one({
'session_id': 'abcdefghijklmnopqrstuvwyzabcdef',
'email': '*****@*****.**'
})
DB.User.insert_one({
'name': 'Test User',
'email': '*****@*****.**',
'password': '******',
'age': 22,
'genre': ['Mystery', 'Horror']
})
DB.User.insert_one({
'name': 'Test User2',
'email': '*****@*****.**',
'password': '******',
'age': 22,
'genre': ['Mystery', 'Horror']
})
DB.User.insert_one({
'name': 'weird name',
'email': '*****@*****.**',
'password': '******',
'age': 22,
'genre': ['Mystery', 'Horror']
})
def setUp(self):
APP.config['TESTING'] = True
APP.config['DEBUG'] = False
APP.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/transport_test'
self.app = APP.test_client()
DB.drop_all()
DB.create_all()
self.lifegoup1 = {
'name': 'uq1',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup2 = {
'name': 'uq2',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup3 = {
'name': 'uq3',
'password': '******',
'email': '*****@*****.**'
}
DB.session.add(LifegroupModel(**self.lifegoup1))
DB.session.add(LifegroupModel(**self.lifegoup2))
DB.session.add(LifegroupModel(**self.lifegoup3))
DB.session.commit()
self.assertFalse(APP.debug)
def run(self):
from app import APP
APP.Functions.set_process_name ( "0@TFTPD_DATA" )
logger = APP.LoggingClient ( name = "TFTPD%05d" % self.pid )
queue_errors = 0
while 1:
try:
(client_address, initiating_packet, filename, filesize) = self.rfQueue.get()
except:
queue_errors += 1
if queue_errors > 2:
logger ("Too many errors reading rfqueue")
break
time.sleep(queue_errors)
queue_errors = 0
if client_address is None: break
logger ("Sending %s to %s" % (filename, client_address))
try:
with open(filename, 'r') as source:
try:
(bytes, dt, speed) = Protocol.Handle_RRQ (initiating_packet, client_address, source)
logger ( "Sent %d bytes to %s at %.1f kB/s" % (bytes, client_address, speed/ 1024) )
except Protocol.TFTPProtocolError as e:
logger ( "TFTP Protocol Error: %s" % e )
except:
info = sys.exc_info()[:2]
logger ( "TFTP error: %s, %s" % (info[0], info[1]))
logger ( "EXIT" )
def __init__(self):
from app import APP
Server.BaseTFTPServer.__init__(self)
APP.Functions.set_process_name ( "0@TFTPD_LISTEN" )
self.logger = APP.LoggingClient ( name="TFTPD_SRV" )
#The queue for "ready-to-be-sent" files
self.rfQueue = Queue(2048)
#The base oven & cook - simple TFTP
base_oven = FileOven ( root = APP.BE.TFTP.dir, name="FILES" )
self.logger ( "Setting up %s." % base_oven )
base_queue_size = APP.BE.TFTP._i_queue_size
base_cook_queue = Queue(base_queue_size)
#The cook for cm firmware files
cm_fw_oven = FileOven ( root = APP.BE.DOCSIS.fwdir, name="CM FW" )
self.logger ( "Setting up %s." % cm_fw_oven )
cm_fw_oven.deny ( (0,0) )
cm_fw_queue = Queue(16)
#The cook for cm config files
cm_cfg_oven = CableModemConfigOven ( root = APP.BE.DOCSIS.dir, name="CM CONFIG" )
self.logger ( "Setting up %s." % cm_cfg_oven )
cm_cfg_oven.deny ( (0,0) )
cm_cfg_queue_size = APP.BE.DOCSIS._i_tftp_queue_size
cm_cfg_queue = Queue (cm_cfg_queue_size)
#The sub-processes count
base_cooks_count = APP.BE.TFTP._i_cooks
cm_fw_cooks_count = APP.BE.DOCSIS._i_tftp_cm_fw_cooks
cm_cfg_cooks_count = APP.BE.DOCSIS._i_tftp_cm_cfg_cooks
self.cooks = [
(cm_cfg_oven, cm_cfg_queue, [CableModemConfigCook(cm_cfg_queue, self.rfQueue, cm_cfg_oven) for i in range(0,cm_cfg_cooks_count)]),
(cm_fw_oven, cm_fw_queue, [FileCook(cm_fw_queue, self.rfQueue, cm_fw_oven) for i in range(0,cm_fw_cooks_count)] ),
(base_oven, base_cook_queue, [FileCook(base_cook_queue, self.rfQueue, base_oven) for i in range(0,base_cooks_count)]),
]
self.logger ( "Starting the cooks." )
#run cooks, run!
for (_,_,cooklist) in self.cooks:
for cook in cooklist: cook.start()
data_senders_count = APP.BE.TFTP._i_senders
self.data_senders = [ TFTPDataSender (self.rfQueue) for i in range(0,data_senders_count) ]
for sender in self.data_senders: sender.start()
signal.signal ( signal.SIGHUP, self.shutdown )
self.on = True
#self.timeout = 4
error_count = 0
while self.on:
try:
self.handle_request()
except Exception as e:
error_count += 1
self.logger ( "error#%d in handle_request (%s)" % (error_count, e) )
if error_count > 10: break
self.logger ( "TFTP service no longer active." )
def setUp(self):
'''
Sets up the 'app.py' fixture
'''
self.middleware = []
self.test_app = TestApp(APP.wsgifunc(*self.middleware))
session.set_up(self.test_app)
model.star_module("BT5110", session.DUMMY_USER_ID)
def test_negative_route_people(self):
"""Verify that the API returns error on wrong link for friends names."""
tester = APP.test_client(self)
response = tester.get(
"paranuara//peOPle/person1=Decker%20Mckenzie&person2=Rosemary%20Hayes",
content_type="application/json",
)
self.assertNotEqual(response.status_code, 200)
def test_positive_route_people(self):
"""Verify that the API works for the friends names."""
tester = APP.test_client(self)
response = tester.get(
"/paranuara/people/?person1=Decker%20Mckenzie&person2=Rosemary%20Hayes",
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
def test_register(self):
""" Hitting Register API """
tester = APP.test_client(self)
url = '/register?userName=Rutu&password=rotadu'
response = tester.post(url, content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.decode("UTF-8"),
"This UserName Already exists.")
def test_logout(self):
"""
A test for loading of the editrecipe page
The url endpoint is;
=> /logout (get)
"""
r = APP.test_client(self)
return r.get('/logout', follow_redirects=True)
def test_url_not_in_form_data_post(self):
"""
Asserts the endpoint fails when the url is not in the form data
"""
with APP.test_client() as client:
sent = {}
result = client.post('/scrape_reviews', data=sent)
self.assertEqual(result.status_code, 400)
def test_url_is_not_restaurant_page_fails(self):
"""
Asserts the endpoint fails when the url is a not a restaurant or review url
"""
with APP.test_client() as client:
sent = {"url": "www.google.com"}
result = client.post('/scrape_reviews', data=sent)
self.assertEqual(result.status_code, 400)
def test_create_a_ride(self):
"""test to create a ride"""
tester = APP.test_client(self)
info = dict(From="mukono", To="kampala", Time="4:00pm", Date="4/4/2018",
Driver_Username="******", Cost="4000", rideID=4)
response = tester.post('/v1/create_ride', data=json.dumps(info),
content_type="application/json")
self.assertEqual(response.status_code, 200)
def setUp(self):
"""Set up tests"""
CATEGORIES.clear()
self.user_email = "*****@*****.**"
self.username = "******"
self.user_password = "******"
APP.config['TESTING'] = True
self.test_app = APP.test_client()
def test_valid_user_registration(self):
"""test registration api"""
tester = APP.test_client(self)
info = dict(firstname="john", lastname="Smith", username="******",
password="******", gender="male", id=4)
response = tester.post('/v1/register', data=json.dumps(info),
content_type="application/json")
self.assertEqual(response.status_code, 200)
def run(self):
self.logging_server = APP.LoggingServer()
self.logger = APP.LoggingClient(name="MAIN")
logger = self.logger
logger("-=<" + ("-" * 70) + ">=-")
logger("Provisioning v0.01, started.")
self.controllers = {}
for (cname, cpath) in APP.BE.CONTROLLER:
self.controllers[cname] = cpath
self.processes = {}
self.start_services()
self.cli = APP.CLIServer()
self.cli.serve()
self.exit()
def client(db):
# create temp upload folder
upload_dir = tempfile.mkdtemp()
APP.config['UPLOAD_FOLDER'] = upload_dir
yield APP.test_client()
# delete temp upload folder
shutil.rmtree(upload_dir)
def a_client():
APP.config['TESTING'] = True
disconnect()
connect('mongoenginetest', host='mongomock://localhost')
client = APP.test_client()
yield client
disconnect()
def __init__(self, **kwargs):
from meta import Table, Field
pg.DB.__init__(self, **kwargs)
#Attempt to make sure this class is a singleton.
CFG.tCX.instanceCount += 1
APP.log("tCX init [%d]" % self.instanceCount)
self.schemaname = CFG.DB.SCHEMA
idmap = {}
tableinfo = self.query ( "SELECT * FROM ONLY {0}.table_info".format(CFG.DB.SCHEMA) ).dictresult()
for ti in tableinfo:
with Table.New ( ti['name'], **ti ) as t:
columninfo = self.query ( "SELECT * FROM ONLY {0}.field_info WHERE classid = {objectid}".format(CFG.DB.SCHEMA, **ti)).dictresult()
for ci in columninfo:
t.addField ( Field (size=ci['length'], **ci) )
idmap[t.objectid] = t
t.recordlisttoolbox = text_to_array ( t.recordlisttoolbox, 0 )
t.recordlistpopup = text_to_array ( t.recordlistpopup, 0 )
#import foreign key relationships
for t in Table.__all_tables__.values():
if t.superclass: t.superclass = idmap[t.superclass]
else: t.superclass = None
for f in t.fields:
#For columns that reference a table_info row, replace the appropriate
#values with actual, python-object references
if f.reference:
f.reference = idmap[f.reference]
#fill the table's children list
f.reference.reference_child.append ( (t, f) )
f.reference.reference_child_hash[t.name + "_" + f.name] = (t,f)
if f.arrayof:
f.arrayof = idmap[f.arrayof]
#import many-to-many relationships
mtm_info = self.query ( "SELECT * FROM ONLY {0}.mtm_relationship".format(CFG.DB.SCHEMA) ).dictresult()
for mtm in mtm_info:
table1 = Table.Get ( mtm['table_1'] )
table2 = Table.Get ( mtm['table_2'] )
table1.mtm_relationships[ mtm['table_1_handle'] ] = (
mtm['relationship_name'], mtm['mtm_table_name'], "refobjectid1", "refobjectid2", table2 )
table2.mtm_relationships[ mtm['table_2_handle'] ] = (
mtm['relationship_name'], mtm['mtm_table_name'], "refobjectid2", "refobjectid1", table1 )
self.instance = self
def _create_default_field_editor (self, field, parent=None, **kwargs):
from app import APP
editor_class_name = field.editor_class
default_class = EntryWidgets.Text
options = {}
prefix = ''
suffix = ''
if self.form.is_field_fixed ( field.name ):
editor_class_name = 'Static'
if field.isarray:
if field.arrayof:
editor_class_name = "List"
prefix = "Array"
options['recordlist'] = RecordList ( field.arrayof ).reload()
default_class = EntryWidgets.ArrayCombo
else:
prefix = 'Array'
default_class = EntryWidgets.ArrayText
elif field.reference:
suffix = 'Reference'
default_class = EntryWidgets.ListReference
wanted_class_name = prefix + editor_class_name + suffix
print field, field.editor_class, wanted_class_name
if hasattr (EntryWidgets,wanted_class_name ):
editor_class = getattr(EntryWidgets, wanted_class_name)
elif APP.getExtraDataEditor (wanted_class_name):
editor_class = APP.getExtraDataEditor (wanted_class_name)
else:
editor_class = default_class
editor = editor_class (field, parent, variable = self.form.getvar(field.name), **options )
return editor
def test_default_route(self):
tester = APP.test_client(self)
response = tester.get('/', content_type='application/json')
# Check 200 response from default route
self.assertEqual(response.status_code, 200)
# Check default route message output
self.assertEqual(json.loads(response.data.decode('utf-8')),
{
"message" : "Hello pythonistic world"
}
)
# Check number of characters in message
response.json = json.loads(response.data.decode('utf-8'))
self.assertEqual(len(response.json['message']), 23)
def test_mailing():
''' mailing functions '''
sender = TEST_USER[0]['email']
recipients = [TEST_USER[1]['email']]
subject = 'Testsubject'
body = 'Testbody'
with APP.app_context():
with MAIL.record_messages() as outbox:
mailing.send_email(sender=sender,
subject=subject,
recipients=recipients,
body=body)
assert outbox[0].sender == sender
assert outbox[0].recipients == recipients
assert outbox[0].subject == subject
assert body in outbox[0].body
# -*- coding: utf-8 -*-
from app import APP
if __name__ == "__main__":
APP.run(debug=True, host="0.0.0.0", threaded=True)
def run():
with Valves() as valves:
APP.valves = valves
APP.run(APP.config['HOST'], APP.config['PORT'], debug=True)
def setUp(self):
app_de_teste.config['TESTING'] = True
app_de_teste.config['WTF_CSRF_ENABLED'] = False
app_de_teste.config['DEBUG'] = False
self.app = app_de_teste.test_client()
'''launcher'''
from app import APP
if __name__ == '__main__':
APP.run('127.0.0.1', debug=True, threaded=True)
#!/usr/bin/env python
"""
Run the server for the app.
Note: Run as root on production, and user locally.
"""
from getpass import getuser
from app import APP
from util import parse_args
parse_args()
if getuser() == "root":
APP.run(debug=False, host="172.31.11.17", port=80)
else:
APP.run(debug=True)
def test_whatsup_post(client, test_user):
with APP.app_context():
with MAIL.record_messages() as outbox:
# add post
login(client, test_user['email'], test_user['password'])
add_whatsup_post(client, 'subject', 'body')
# logout and try to access it
logout(client)
rv = client.get('/whatsup/1')
assert rv.status_code == 302
# login again
login(client, test_user['email'], test_user['password'])
# add comment
rv = add_whatsup_comment(client, 1, 'cömment1')
assert rv.status_code == 200
assert 'Kommentar abgeschickt!' in rv.data
# database entries
rv = models.get_whatsup_post(1)
assert rv.comments[0].body == 'cömment1'.decode('utf-8')
assert rv.comments[0].post_id == 1
assert rv.comments[0].user_id == test_user['id']
# add 3 more comments
sleep(1)
add_whatsup_comment(client, 1, 'comment2')
sleep(1)
add_whatsup_comment(client, 1, 'comment3')
sleep(1)
add_whatsup_comment(client, 1, 'comment4')
assert len(models.get_whatsup_post(1).comments) == 4
# create soup
rv = client.get('/whatsup/1')
soup = BeautifulSoup(rv.data)
rv = soup.find_all('div', class_='media-body')
# discussion icon counter
assert '4' in rv[0].text
# checking comment order
assert 'comment4' in rv[1].text
assert 'comment3' in rv[2].text
assert 'comment2' in rv[3].text
assert 'cömment1'.decode('utf-8') in rv[4].text
# checking names
assert '{} {}'.format(
test_user['vorname'],
test_user['name']) in rv[0].text.encode('utf-8')
assert '{} {}'.format(
test_user['vorname'],
test_user['name']) in rv[1].text.encode('utf-8')
assert '{} {}'.format(
test_user['vorname'],
test_user['name']) in rv[2].text.encode('utf-8')
assert '{} {}'.format(
test_user['vorname'],
test_user['name']) in rv[3].text.encode('utf-8')
assert '{} {}'.format(
test_user['vorname'],
test_user['name']) in rv[4].text.encode('utf-8')
# check notification emails
assert outbox[0].sender == '{} {} <{}>'.format(
unidecode(test_user['vorname'].decode('utf-8')), unidecode(
test_user['name'].decode('utf-8')), test_user['email'])
assert outbox[0].subject == 'Kommentar in "{}"'.format('subject')
assert '{} {} hat geschrieben:'.format(
unidecode(test_user['vorname'].decode('utf-8')),
unidecode(test_user['name'].decode('utf-8'))) in outbox[0].body
assert 'cömment1'.decode('utf-8') in outbox[0].body
assert '/whatsup/1' in outbox[0].body
def stream_template(templatename, **context):
APP.update_template_context(context)
template = APP.jinja_env.get_template(templatename)
rv = template.stream(context)
rv.enable_buffering(5) # you might want to buffer up a few items in the template
return rv
# -*- encoding: utf-8 -*-
'''
Current module: pyrunnerwbs.run
Rough version history:
v1.0 Original version to use
********************************************************************
@AUTHOR: Administrator-Bruce Luo(罗科峰)
MAIL: [email protected]
RCS: pyrunnerwbs.run,v 1.0 2016年4月24日
FROM: 2016年4月24日
********************************************************************
======================================================================
UI and Web Http automation frame for python.
'''
from app import APP
APP.run(debug=True)
#!/usr/bin/python ''' :since: 01/08/2015 :author: oblivion ''' from app import APP APP.run(debug=APP.config['DEBUG'], host='0.0.0.0')
def setUp(self):
APP.config["TESTING"] = True
self.app = APP.test_client()
