def test(self):
app = App()
if os.environ.get("run") == "all":
self.failIf(app.multiply(2,3) != 6)
self.failIf(app.sum(1,1) != 2)
self.failIf(app.diff(1,1) != 0)
self.failIf(app.divide(1,1) != 1)
else:
self.failIf(app.sum(1,1) != 2)
def __init__(self):
# Init related objects
self.app = App(self)
self.installer = Installer(self)
self.local_op = LocalOperations()
self.remote_op = RemoteOperations(self)
self.printer = Printer()
self.connect()
self.setup()
def test_read():
hour = datetime.datetime.now().isoformat()
temperature = 14.52
temperature_by_hour = {hour: temperature}
data_source = MagicMock()
data_source.read.return_value = temperature_by_hour
app = App(data_source=data_source, plot=MagicMock())
assert app.read(file_name='something.csv') == temperature_by_hour
def __init__(self,
app_path,
device_serial,
output_dir=None,
env_policy=None,
event_policy=None,
with_droidbox=False,
event_count=None,
event_interval=None,
event_duration=None,
quiet=False):
"""
initiate droidbot with configurations
:return:
"""
logging.basicConfig(level=logging.WARNING if quiet else logging.INFO)
self.logger = logging.getLogger('DroidBot')
DroidBot.instance = self
self.output_dir = output_dir
if self.output_dir is None:
self.output_dir = os.path.abspath("droidbot_out")
if not os.path.exists(self.output_dir):
os.mkdir(self.output_dir)
# if device_serial is None:
# # Dirty Workaround: Set device_serial to Default='.*', because com/dtmilano/android/viewclient.py
# # set serial to an arbitrary argument. IN connectToDeviceOrExit(..) line 2539f.
# # FIXED by requiring device_serial in cmd
# device_serial = '.*'
self.device = Device(device_serial, output_dir=self.output_dir)
self.app = App(app_path, output_dir=self.output_dir)
self.droidbox = None
self.env_manager = None
self.event_manager = None
self.enabled = True
try:
if with_droidbox:
self.droidbox = DroidBox(droidbot=self,
output_dir=self.output_dir)
self.env_manager = AppEnvManager(self.device, self.app, env_policy)
self.event_manager = AppEventManager(self.device, self.app,
event_policy, event_count,
event_interval,
event_duration)
except Exception as e:
import traceback
traceback.print_exc()
self.stop()
print e
def amdh():
arguments = args_parse()
if arguments.adb_path:
adb_path = arguments.adb_path
dump_apks = False
apks_dump_folder = ""
if arguments.apks_dump_folder:
dump_apks = True
apks_dump_folder = arguments.apks_dump_folder
adb_instance = ADB(adb_path)
device_id = device_choice(adb_instance)
adb_instance = ADB(adb_path, device_id)
settings_check = None
packages = []
if arguments.app_type:
packages = adb_instance.list_installed_packages(arguments.app_type)
report_apps = {}
for package in packages:
dumpsys_out = adb_instance.dumpsys(["package", package])
perm_list = adb_instance.get_req_perms_dumpsys_package(dumpsys_out)
app = App(adb_instance, package, dump_apks, apks_dump_folder,
perm_list)
perms, dangerous_perms = app.check_apps()
print("")
if dangerous_perms.items():
print_warning_header("Package " + package +
" have some dangerous permissions: ")
for perm, desc in dangerous_perms.items():
print_warning("\t " + perm + " : ")
print_warning("\t\t" + desc)
report_apps[package] = {
"permissions": perms,
"dangerous_perms": dangerous_perms
}
print("")
print(
"************************************************************************"
)
else:
print_info("Package " + package + " have no dangerous permissions")
print("")
print(
"************************************************************************"
)
if arguments.H:
settings_check = Settings(settings_file, adb_instance, True)
else:
settings_check = Settings(settings_file, adb_instance)
settings_check.check()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-l',
action='store_true',
help='Fetch lyrics of the given artists.')
parser.add_argument('-a',
action='store_true',
help='Analyze the given lyrics.')
args = parser.parse_args()
def start_scrape(app):
print('--- Lyrics Scrape ---')
scrape_validation_errors = Utils.validation('scrape')
if not scrape_validation_errors:
values = Utils.get_config_values('artists_input_file',
'lyrics_result_file')
app.scrape(token=config['genius_api_token'],
artists_input=values['artists'],
lyrics_result=values['lyrics'])
else:
for error in scrape_validation_errors:
print(error)
exit(0)
def start_analyze(app):
print('\n--- Lyrics Analyze ---')
analyze_validation_errors = Utils.validation('analyze')
if not analyze_validation_errors:
analyze_threshold = -1
if 'analyze_threshold' in config:
analyze_threshold = config['analyze_threshold']
values = Utils.get_config_values('lyrics_result_file',
'stats_result_file')
app.analyze(lyrics_result=values['lyrics'],
stats_result=values['stats'],
analyze_threshold=analyze_threshold)
else:
for error in analyze_validation_errors:
print(error)
exit(0)
scrape, analyze = args.l, args.a
app = App()
if not scrape and not analyze:
# Default behavior. Both scrape and analyze.
start_scrape(app)
start_analyze(app)
else:
# One or both of the arguments are given.
if scrape:
start_scrape(app)
if analyze:
start_analyze(app)
sys.exit(0)
def main():
stats = get_stats()
try:
rows, cols, num_mines = int(argv[1]), int(argv[2]), int(argv[3])
except:
rows = cols = 8
num_mines = 10
app = QApplication(argv)
ex = App(rows=rows, cols=cols, num_mines=num_mines, stats=stats)
app.exec_()
def setUp(self):
self.input = MagicMock()
# swipe somewhere (south):
self.input.getline = MagicMock(return_value='s')
self.output = MagicMock()
self.output.write = MagicMock()
self.app = App(self.input, self.output)
self.app.renderer = create_autospec(Renderer) # type: MagicMock
def run():
"""
Bootstraps an App and serves it with waitress.
:return:
"""
config = read_config()
app = App(config)
server_config = config['server']
serve(app.flask_app, host=server_config['host'], port=server_config['port'], threads=8)
def setUp(self):
self.app = App(
db_path="rapidapi_test.sqlite3",
file_path="test.json"
)
self.data = [
{"game": "pokemon","level":1,"max_points":200,"player": "me"},
{"game": "pokemon","level":2,"max_points":100,"player": "you"}
]
self.df = self.app.pandas_dataframe(self.data)
def options(path):
app = App()
app.check_origin()
response = app.cross_response(response='put')
if path.startswith('rw/'):
response.headers['Access-Control-Allow-Methods'] = 'GET, PUT'
elif path.startswith('r/'):
response.headers['Access-Control-Allow-Methods'] = 'GET'
return response
def test_server(port):
"""Start a server to test against"""
app = App(port=port)
try:
thread = threading.Thread(target=app.start)
thread.daemon = True
thread.start()
yield app
finally:
app.stop()
def test_draw(monkeypatch):
plot_mock = MagicMock()
app = App(data_source=MagicMock(), plot=plot_mock)
hour = datetime.datetime.now()
iso_hour = hour.isoformat()
temperature = 14.52
temperature_by_hour = {iso_hour: temperature}
app.draw(temperature_by_hour)
plot_mock.draw.assert_called_with([hour], [temperature])
def main():
ev_manager = EventManager()
main_frame = MainFrame(ev_manager)
spinner = CPUSpinnerController(ev_manager)
keybd = KeyboardController(ev_manager)
ai = Agent(ev_manager)
app = App(ev_manager)
spinner.run()
def start_server(tmp_dir, port_file, icon_file, python_path, data_dir):
app = App(tmp_dir, port_file, icon_file, python_path, data_dir)
app.build_ui()
open_files_from_tmp(app)
app.run_command('show_home')
open_files_from_arg(sys.argv, app)
port = find_free_port()
with open(app.port_file, 'w') as file:
file.write(str(port))
app.run(port)
def testCashboxAmount(self):
a = App()
a.cashboxBal = 200000
a.emps = [(1, 1, 5000, 5000, 300), (2, 1, 9000, 0, 1000),
(3, 1, 20000, -400, 0), (4, 2, 10000, 0, 100),
(5, 3, 110000, 0, 0)]
a.process()
self.assertEqual(a.cashbox, 47210.00)
self.assertEqual(a.cashShort, 0.00)
print("----")
def buy(current_account):
price = float(request.args.get('price'))
user = App().mongo.db.user
result = user.find_one({'name': current_account})
if result.get("wallet") and result.get("wallet") >= price:
result["wallet"] -= price
user.save(add_record(result, price, buy=True))
else:
return '余额不足'
return redirect('/records')
def test_it_gets_rsvps_for_upcoming_event(self):
sesClient = getSesClientMock()
meetupClient = getMeetupClientMock(
rsvps=getFixtureRsvps(),
event=getFixtureEvent(),
)
app = App(sesClient, meetupClient)
app.run(GROUP_URLNAME, DEFAULT_NOTIFY_PERIOD_HOURS)
meetupClient.getRsvpsForMeetup.assert_called_with(getFixtureEvent()['id'])
def test_it_does_not_send_email_when_there_are_no_rsvp_answers(self):
sesClient = getSesClientMock()
meetupClient = getMeetupClientMock(
rsvps=getFixtureRsvps(False),
event=getFixtureEvent(),
)
app = App(sesClient, meetupClient)
app.run(GROUP_URLNAME, DEFAULT_NOTIFY_PERIOD_HOURS)
sesClient.send.assert_not_called()
def run(**kwargs) -> None:
"""Update path and run the App."""
# update the path to ensure the App has access to required modules
app_lib = AppLib()
app_lib.update_path()
# import modules after path has been updated
# third-party
from tcex import TcEx # pylint: disable=import-outside-toplevel
# first-party
from app import App # pylint: disable=import-outside-toplevel
tcex = TcEx()
try:
# load App class
app = App(tcex)
# set app property in testing framework
if callable(kwargs.get('set_app')):
kwargs.get('set_app')(app)
# configure custom trigger message handler
tcex.service.create_config_callback = app.create_config_callback
tcex.service.delete_config_callback = app.delete_config_callback
tcex.service.shutdown_callback = app.shutdown_callback
# perform prep/setup operations
app.setup(**{})
# listen on channel/topic
tcex.service.listen()
# start heartbeat threads
tcex.service.heartbeat()
# inform TC that micro-service is Ready
tcex.service.ready = True
# run app logic
app.run(**{})
# perform cleanup/teardown operations
app.teardown(**{})
# explicitly call the exit method
tcex.playbook.exit(msg=app.exit_message)
except Exception as e:
main_err = f'Generic Error. See logs for more details ({e}).'
tcex.log.error(traceback.format_exc())
tcex.playbook.exit(1, main_err)
def app_init(self, args):
"""Return an instance of App."""
from app import App # pylint: disable=import-error
# return App(self.get_tcex(args))
args = args or {}
# update App paths
args['tc_in_path'] = os.path.join(self.default_args.get('tc_in_path'),
self.test_case_feature)
args['tc_log_path'] = os.path.join(
self.default_args.get('tc_log_path'), self.test_case_feature,
self.test_case_name)
args['tc_out_path'] = os.path.join(
self.default_args.get('tc_out_path'), self.test_case_feature,
self.test_case_name)
args['tc_temp_path'] = os.path.join(
self.default_args.get('tc_temp_path'), self.test_case_feature,
self.test_case_name)
# update default args with app args
app_args = dict(self.default_args)
app_args.update(args)
# app_args['tc_log_file'] = '{}.log'.format(self.test_case_name)
app_args['tc_logger_name'] = self.context
if self.install_json.get('runtimeLevel').lower() in [
'triggerservice',
'webhooktriggerservice',
]:
# service Apps will get their args/params from encrypted file in the "in" directory
data = json.dumps(app_args, sort_keys=True).encode('utf-8')
key = ''.join(
random.choice(string.ascii_lowercase) for i in range(16))
fp = FileParams()
fp.EVP_EncryptInit(fp.EVP_aes_128_cbc(), key.encode('utf-8'),
b'\0' * 16)
encrypted_data = fp.EVP_EncryptUpdate(data) + fp.EVP_EncryptFinal()
app_params_json = os.path.join(self.test_case_feature_dir,
'.app_params.json')
with open(app_params_json, 'wb') as fh:
fh.write(encrypted_data)
# create environment variable for tcex inputs method to pick up to read encrypted file
os.environ['TC_APP_PARAM_KEY'] = key
os.environ['TC_APP_PARAM_FILE'] = app_params_json
# tcex will read args/params from encrypted file
tcex = TcEx()
else:
tcex = TcEx(config=app_args)
return App(tcex)
def test_plaintext():
"""/plaintext"""
app = App()
c = Client(app)
response = c.get('/plaintext', status=200)
assert response.headerlist == [
('Content-Type', 'text/plain; charset=UTF-8'),
('Content-Length', '13')
]
assert response.text == 'Hello, World!'
def test_json():
"""/json"""
app = App()
c = Client(app)
response = c.get('/json', status=200)
assert response.headerlist == [
('Content-Type', 'application/json'),
('Content-Length', '27')
]
assert response.json == {"message": "Hello, World!"}
def test_it_sends_email_when_there_are_rsvps_answers(self):
sesClient = getSesClientMock()
meetupClient = getMeetupClientMock(
rsvps=getFixtureRsvps(),
event=getFixtureEvent(),
)
app = App(sesClient, meetupClient)
app.run(GROUP_URLNAME, DEFAULT_NOTIFY_PERIOD_HOURS)
expectedEventStartTime = datetime.datetime.fromtimestamp(getFixtureEvent()['time'] / 1000)
sesClient.send.assert_called_with(f'RSVPs for Group-Urlname event on {str(expectedEventStartTime)} (UTC)', f'RSVP answers for the Group-Urlname MeetUp event scheduled on {str(expectedEventStartTime)} (UTC)\n\nI have a disability\nI have another disability')
def test_db():
"""/db"""
app = App()
c = Client(app)
response = c.get('/db', status=200)
assert response.content_type == 'application/json'
assert 'id' in response.json
assert 'randomNumber' in response.json
assert 1 <= response.json['id'] <= 10000
assert 1 <= response.json['randomNumber'] <= 10000
def token():
parser = argparse.ArgumentParser(description='AWS STS MFA Token Generator')
parser.add_argument('-n',
'--profile-name',
help='Profile Name',
required=True)
parser.add_argument('--credential-file',
help='Location of AWS Credential File')
args = parser.parse_args()
options = vars(args)
my_app = App(options)
def test_fortunes():
"""/fortunes"""
app = App()
c = Client(app)
response = c.get('/fortunes', status=200)
assert response.headerlist == [
('Content-Type', 'text/html; charset=UTF-8'),
('Content-Length', '1304')
]
assert response.text == fortunes
def main():
inputs = [
"tests/me_at_the_zoo.in", "tests/videos_worth_spreading.in",
"tests/trending_today.in", "tests/kittens.in"
]
app = App(inputs[2])
app.sortEdges()
app.solveAllEdges()
print(app.generateOutput())
def main():
"""
solver, scrambler = Solver(), Scrambler()
scramble_moves = scrambler.generate_scramble_moves()
print('\n'.join(scramble_moves))
solver.scramble(scramble_moves)
print(' '.join(solver.solve()))
"""
app = QApplication(argv)
ex = App()
app.exec_()
def test_it_exits_if_upcoming_event_is_far_into_the_future(self):
sesClient = getSesClientMock()
eventFixture = getFixtureEvent()
meetupClient = getMeetupClientMock(
rsvps=getFixtureRsvps(),
event=eventFixture,
)
app = App(sesClient, meetupClient)
sesClient.send.assert_not_called()
self.assertFalse(app.run(GROUP_URLNAME, 1))
