def test_remaining_principle_calculator(self):
debts, expected_results, discretionary = loadDebtsfromFile(
os.path.join('TestFiles', 'heloc_vs_amortized.csv'), "avalanche")
print(debts)
heloc = debts[0]
amortized = debts[1]
print('\nresults')
print(expected_results)
actual_amortized, _ = main([amortized],
0.0,
actionMonths=12,
method="avalanche")
print(actual_amortized)
self.assertAlmostEqual(expected_results[1][0],
actual_amortized[0][5],
delta=5.0)
self.assertEqual(expected_results[1][2], actual_amortized[0][3])
actual_heloc, _ = main([heloc],
0.0,
actionMonths=12,
method="avalanche")
print(actual_heloc)
self.assertAlmostEqual(expected_results[0][0],
actual_heloc[0][5],
delta=125.0)
self.assertEqual(expected_results[0][2], actual_heloc[0][3])
def demo_status():
# global video_camera
# if video_camera == None:
# video_camera = VideoCamera()
json = request.get_json()
status = json['status']
print('kms!', file=sys.stderr)
sys.stderr.flush()
if status == "true":
# app.logger.warning('A warning occurred (%d apples)', 42)
# app.logger.error('An error occurred')
# video_camera.start_record()
print("testing INFO", file=sys.stderr)
sys.stderr.flush()
sys.stdout.flush()
lib_processing.main()
return jsonify(result="started")
else:
print("rip in pieces", file=sys.stderr)
sys.stderr.flush()
# video_camera.stop_record()
return jsonify(result="stopped")
def test_main_exits_with_code_1_if_config_validation_fails(self, config_validator_mock, exit_stub):
mock_validator = Mock()
mock_validator.is_valid = Mock(return_value=False)
config_validator_mock.return_value = mock_validator
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
def batch_main():
"""Executes main function in a batch"""
for year in (2015, 2016, 2017, 2018, 2019):
SETTINGS['cutoff_value'] = year
SETTINGS['log_name'] = f'{year}_log.txt'
SETTINGS['csv_name'] = f'{year}_firepoints.csv'
main(**SETTINGS)
def solution_works(test, a):
with mock.patch('__builtin__.raw_input', side_effect=[a]):
captured_output = StringIO.StringIO()
sys.stdout = captured_output
main()
sys.stdout = sys.__stdout__
test.assertTrue((len(captured_output.getvalue()) > 0),
msg="You did not print anything!")
test.assertTrue(
("is " in captured_output.getvalue()),
msg=
"You should output \"Number INPUT is odd/even\" to print the result. You printed: "
+ captured_output.getvalue())
test_result = captured_output.getvalue(
)[captured_output.getvalue().index('is ') + len('is '):]
if a % 2 == 0:
correct_answer = 'even'
else:
correct_answer = 'odd'
test.assertTrue(correct_answer in captured_output.getvalue(),
msg="Number " + str(a) + " is " + str(correct_answer) +
" you proposed: " + test_result)
def test_main_exits_with_code_1_if_not_all_protected_playlists_exist(self, get_config_stub, config_validator_mock,
setup_logger_mock, helper_mock, integrity_mgr_mock,
cleaner_mock, moderate_playlists_mock, exit_stub):
only_playlist = { 'uri': self.generate_playlist_uri() }
get_config_stub.return_value = ({
'PROTECT_ALL': False,
'PROTECTED_PLAYLISTS': []
}, {}, {
'CLIENT_ID': 'spotifyclientid',
'CLIENT_SECRET': 'spotifyclientsecret',
'REDIRECT_URI': 'http://localhost:8080',
'USERNAME': '******'
})
mock_validator = Mock()
mock_validator.is_valid.return_value = True
mock_validator.all_protected_playlists_exist.return_value = False
config_validator_mock.return_value = mock_validator
configure_api_stub = Mock()
configure_api_stub.configure_api.return_value = spotipy.client.Spotify()
helper_mock.return_value = configure_api_stub
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
moderate_playlists_mock.assert_not_called()
def test_second_of_the_year(self):
answer = "31536000"
captured_output = StringIO.StringIO()
sys.stdout = captured_output
main()
sys.stdout = sys.__stdout__
self.assertTrue((answer in captured_output.getvalue()),
msg="Printed value is not correct!")
def test_plugin(self):
projectName = "ImageJ filter sobel"
self.logger.info(
"Testing the op: {} with overloading option: {}".format(projectName, op)
)
method_call_types = {}
supported_data_types = [
"double",
"float",
"long",
"int",
"short",
"char",
"byte",
"boolean",
]
# Get WIPP and ImageJ data types
_opName = op
_in1_wipp_types = {"SobelRAI": "collection"}
_in1_imagej_types = {"SobelRAI": "RandomAccessibleInterval"}
if _in1_wipp_types.get(op, None) != "collection":
method_call_types.update(
{
method: dtype
for method, dtype in _in1_imagej_types.items()
if dtype in supported_data_types
}
)
# Generate data for the inputs
_in1 = self.generate_data(
"in1", _in1_wipp_types.get(op, None), method_call_types.get(op, None)
)
# Handle the op output
_out = self.output_handler("out", "collection")
try:
# Call the op
main(_opName=_opName, _in1=_in1, _out=_out)
self.logger.info(
"SUCCESS: op: {} with option {} was successful\n".format(
projectName, op
)
)
self.summary.info("1")
except Exception:
self.logger.info(
"FAILURE: op: {} with option {} was NOT successful".format(
projectName, op
)
+ "\n"
+ str(sys.exc_info())
)
self.logger.info(traceback.format_exc() + "\n")
self.summary.info("0")
def test_main(self, parser, syncend):
parser.return_value.get_arguments.return_value = (
self.collection_name,
self.postman_api_key,
self.trigger_interval,
self.slack_channel,
self.slack_token,
)
mn.main()
def test_main_validates_configurations_before_setting_up_a_logger(self, config_validator_mock,
load_config_stub, exit_stub):
# The stubbed return value of (False) is_valid() allows main() to quit early
mock_validator = Mock()
mock_validator.is_valid = Mock(return_value=False)
config_validator_mock.return_value = mock_validator
with self.assertRaises(SystemExit) as sys_exit:
main.main()
mock_validator.is_valid.assert_called_once()
def run(hook, _config, c_stages, c_results, _run):
logger = logging.getLogger("{{ cookiecutter.repo_name }}." +
os.path.basename(os.path.splitext(__file__)[0]))
logger.info(_config["timestamp"])
if c_stages["main"]:
main(_config)
ex.add_artifact(os.path.join(c_results["output_path"], "general.log"))
def test_main_exits_with_code_1_if_an_exception_is_raised_when_setting_up_a_loger(self, config_validator_mock,
setup_logger_mock, load_config_stub,
exit_stub):
mock_validator = Mock()
# stubbing is_valid to return True allows the function to continue running beyond validation
mock_validator.is_valid = Mock(return_value=True)
config_validator_mock.return_value = mock_validator
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
def test_gcode_interactive(self):
"""
Test that the flag calls the function with the right argument
:return:
"""
with mock.patch('src.main.interactive_gcode') as mock_func:
with pytest.raises(SystemExit) as cm:
main(["--gi", "--ip=192.168.0.1", "--port=10002", "--vid=0x0403", "--pid=0x6001"])
assert cm.value.code != EXIT_BAD_INPUT
assert cm.value.code == EXIT_SUCCESS
assert mock_func.called
def test_demo_mode(self):
"""
Test that the flag --demo calls the function with the right arguments
:return:
"""
with mock.patch('src.main.demo_mode') as mock_func:
with pytest.raises(SystemExit) as cm:
main(["--demo", "--ip=192.168.0.1", "--port=10002"])
assert cm.value.code != EXIT_BAD_INPUT
assert cm.value.code == EXIT_SUCCESS
assert mock_func.called
def test_main_returns_return_value_of_restore_config_if_rdc_option_in_args(self, restore_stub, exit_stub):
with patch.object(sys, 'argv', ['--rdc']) as stubbed_args:
restore_stub.return_value = 0
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 0)
restore_stub.return_value = 1
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
def test_help(self, capsys, cmd):
"""
Test that the different help options print the doc string of main
:param capsys:
:param cmd:
:return:
"""
with pytest.raises(SystemExit):
main([cmd])
captured = capsys.readouterr().out.strip("\n")
stripped_doc = cli_doc.strip("\n")
assert stripped_doc in captured
def test_main_prints_help_info_and_exits_with_code_0_if_help_option_in_args(self, print_help_mock, exit_stub):
with patch.object(sys, 'argv', [ '--help' ]) as stubbed_args:
with self.assertRaises(SystemExit) as sys_exit:
main.main()
print_help_mock.assert_called_once()
self.assertEqual(sys_exit.exception.code, 0)
with patch.object(sys, 'argv', ['-h']) as stubbed_args:
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(print_help_mock.call_count, 2)
self.assertEqual(sys_exit.exception.code, 0)
def do_POST(self):
content_length = int(
self.headers['Content-Length']) # <--- Gets the size of data
post_data = self.rfile.read(
content_length) # <--- Gets the data itself
logger.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n",
str(self.path), str(self.headers),
post_data.decode('utf-8'))
main(json.loads(post_data.decode('utf-8')))
self._set_response()
self.wfile.write("POST request for {}".format(
self.path).encode('utf-8'))
def test_validate_gcode(self, cmd):
"""
Test that the flags call the function with the right arguments
:param cmd:
:return:
"""
with mock.patch('src.main.check_trajectory') as mock_func:
with pytest.raises(SystemExit) as cm:
main([cmd, 'test.gcode', 'config.ini'])
print(cm)
assert cm.value.code != EXIT_BAD_INPUT
assert cm.value.code == EXIT_SUCCESS
assert mock_func.called
def test_main_exits_with_code_1_if_redirect_uri_is_in_use(self, get_config_stub, config_validator_mock,
setup_logger_mock, helper_mock, exit_stub):
mock_validator = Mock()
# stubbing is_valid to return True allows the function to continue running beyond validation
mock_validator.is_valid = Mock(return_value=True)
config_validator_mock.return_value = mock_validator
configure_api_stub = Mock()
# an OSError is raised when the redirect URI is already in use
configure_api_stub.configure_api.side_effect = OSError('Address already in use')
helper_mock.return_value = configure_api_stub
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
def test_gcode_execution(self):
"""
Test that the flag calls the function with the right argument
:return:
"""
current_file_path = Path(os.path.dirname(os.path.realpath(__file__)))
gcode_file = Path(current_file_path, "cartesian_violation.gcode")
with mock.patch('src.main.execute_gcode') as mock_func:
with pytest.raises(SystemExit) as cm:
main(["--gi", "--ip=192.168.0.1", "--port=10002", "--vid=0x0403", "--pid=0x6001",
f"--f={gcode_file}"])
assert cm.value.code != EXIT_BAD_INPUT
assert cm.value.code == EXIT_SUCCESS
assert mock_func.called
def OnClick():
input_parameters["config_file"] = "GUI"
for param in simulation_parameters:
if param.choices == ["True", "False"]:
input_parameters[param.name] = "True" if int(
getattr(self,
param.name).get()) == 1 else "False"
elif param.name == "grating":
input_parameters["grating"] = str(
self.grating.get()).split("[")[0].strip()
else:
input_parameters[param.name] = param.type(
getattr(self, param.name).get())
from src.main import main
main(input_parameters)
def process(dirname):
filename = datetime.now().isoformat()
f = open(dirname + '/' + filename, 'w')
for file in os.listdir(dirname):
results = main.main(dirname + '/' + file)
f.write(file + " : " + results + "\n")
f.close()
def test_0(self):
db = Database(self.TMPDIR, DataItem)
html = HtmlOutput(self.TMPDIR / "out.html", ["secret", "_id", "detail"])
search = SearchSim()
for loop in range(4):
LOG.info("-------- LOOP %d -------", loop)
main(db, search, html)
cat_file(html.filename)
to_check = {
"table_new" : ["ID0019","ID0021"],
"table_gone" : ["ID0009","ID0011"],
"table_existing" : ["ID0013","ID0015", "ID0017"],
}
self.check_file( html.filename, to_check )
def test_cli_args_noxmit():
x0 = 232323e-6
b = 3.8
text = 'hi'
argv = f'{x0} {b} {text}'.split()
response = main.main(argv)
nums = [int(_) for _ in response.split(',')]
assert nums == [2077, 5]
def test_main_runs_playlist_moderation_until_user_wants_to_exit_if_loop_mode_enabled(self, get_config_stub, config_validator_mock,
setup_logger_mock, helper_mock, integrity_mgr_mock,
cleaner_mock, user_exit_mock, exit_stub):
only_playlist = { 'uri': self.generate_playlist_uri() }
get_config_stub.return_value = ({
'PROTECT_ALL': False,
'PROTECTED_PLAYLISTS': [ { 'playlistlabel': only_playlist } ],
'DELAY_BETWEEN_SCANS': 1
}, {}, {
'CLIENT_ID': 'spotifyclientid',
'CLIENT_SECRET': 'spotifyclientsecret',
'REDIRECT_URI': 'http://localhost:8080',
'USERNAME': '******'
})
mock_validator = Mock()
mock_validator.is_valid.return_value = True
mock_validator.all_protected_playlists_exist.return_value = True
config_validator_mock.return_value = mock_validator
helper_obj = Mock()
helper_obj.configure_api.return_value = spotipy.client.Spotify()
helper_mock.return_value = helper_obj
integrity_mgr_obj = Mock()
playlist_cleaner_obj = Mock()
integrity_mgr_mock.return_value = integrity_mgr_obj
cleaner_mock.return_value = playlist_cleaner_obj
with self.assertRaises(SystemExit) as sys_exit:
# run within SysExit context because main explicitly exits with code 0 after completion
main.main()
self.assertEqual(integrity_mgr_obj.run.call_count, 2)
self.assertEqual(len(integrity_mgr_obj.run.call_args_list[0][0]), 1)
self.assertEqual(integrity_mgr_obj.run.call_args_list[0][0][0], only_playlist)
self.assertEqual(len(integrity_mgr_obj.run.call_args_list[1][0]), 1)
self.assertEqual(integrity_mgr_obj.run.call_args_list[1][0][0], only_playlist)
self.assertEqual(playlist_cleaner_obj.run.call_count, 2)
self.assertEqual(playlist_cleaner_obj.run.call_args_list[0][0][0], only_playlist)
self.assertEqual(len(playlist_cleaner_obj.run.call_args_list[0][0]), 1)
self.assertEqual(playlist_cleaner_obj.run.call_args_list[1][0][0], only_playlist)
self.assertEqual(len(playlist_cleaner_obj.run.call_args_list[1][0]), 1)
def text_reply(msg):
global flag
message = msg['Text']
fromName = msg['FromUserName']
toName = msg['ToUserName']
# logging.error('# 收到命令: ' + message + ",From:" + fromName + ",to:" + toName)
print('# 收到命令: ' + message + ",From:" + fromName + ",to:" + toName)
if toName == 'filehelper':
itchat.send(sendMsg, fromName)
if message == "打卡":
main()
global driver
chromedriver = r"D:\DevPlatform\chromedriver\chromedriver.exe"
os.environ['webdriver.chromedriver'] = chromedriver
driver = webdriver.Chrome(chromedriver)
def test_main_exits_with_code_1_if_api_client_setup_fails(self, get_config_stub, config_validator_mock,
setup_logger_mock, helper_mock, exit_stub):
mock_validator = Mock()
# stubbing is_valid to return True allows the function to continue running beyond validation
mock_validator.is_valid = Mock(return_value=True)
config_validator_mock.return_value = mock_validator
configure_api_stub = Mock()
configure_api_stub.configure_api.side_effect = Exception('401 unauthorized')
helper_mock.return_value = configure_api_stub
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
configure_api_stub.configure_api.side_effect = [ None ]
with self.assertRaises(SystemExit) as sys_exit:
main.main()
self.assertEqual(sys_exit.exception.code, 1)
def test_cli_args():
x0 = 232323e-6
b = 3.8
text = 'hi'
xmit = '--xmit .9'
argv = f'{x0} {b} {text} {xmit}'.split()
response = main.main(argv)
nums = [int(_) for _ in response.split(',')]
assert nums[0] >= 2077 and nums[1] >= 5
def run(args):
"""Run the package's main script. All arguments are passed to it."""
# The main script expects to get the called executable's name as
# argv[0]. However, paver doesn't provide that in args. Even if it did (or
# we dove into sys.argv), it wouldn't be useful because it would be paver's
# executable. So we just pass the package name in as the executable name,
# since it's close enough. This should never be seen by an end user
# installing through Setuptools anyway.
from src.main import main
raise SystemExit(main([CODE_DIRECTORY] + args))
def test_invalid_regex_input(self):
error_message_for_invalid_regex = sys.argv[0].split('\\')[-1]
error_message_for_invalid_regex += ': error: argument -r/--regex: Error in function validate_regex: The regex expression is not valid'
sys.argv.append('-f')
sys.argv.append('/project/tests/dummy_input1.txt')
sys.argv.append('-r')
sys.argv.append('+')
sys.argv.append('-m')
temp_strout = StringIO()
try:
with contextlib.redirect_stderr(temp_strout):
main()
except:
error_line = temp_strout.getvalue().strip().splitlines()[-1]
# bring back the original sys.argv
for par in sys.argv[1:]:
sys.argv.remove(par)
self.assertEqual(error_line, error_message_for_invalid_regex)
#! /usr/bin/env python from src import main main.main()
"\tlegoJson2Pickle: BJ4\n"
)))
if __name__ == '__main__':
# import pdb; pdb.set_trace()
args = sys.argv[1:]
# args[0] = RUN_SHORT_CUT
if not args:
print_usage()
sys.exit(-1)
if args[0] == "help":
print_usage()
elif args[0] == "run":
main()
elif args[0] == "resizeImageCollectioneDir":
if len(args) < 2:
print_usage()
print('Not enough argments')
sys.exit(-1)
resizeImageCollectioneDir(args[1], "output/")
elif args[0] == "coverImageDirToJSON":
if len(args) < 2:
print_usage()
print('Not enough argments')
sys.exit(-1)
coverImageDirToJSON(args[1], "output/alldata.json")
elif args[0] == "legoJson2Pickle":
def test_main_bootstrap(self):
"json is written to stdout"
results = main.main(self.small_doc) # writes article json to stdout
results = json.loads(results)
self.assertTrue('article' in results)
self.assertTrue('journal' in results)
#!/usr/bin/env python3
import sys
from src.main import main
if __name__ == "__main__":
#Check dependencies
main(sys.argv[1:])
# If update_bloomfilter > 0, then every so many seconds an introduction request will be sent
# Introduction request contains the Dispersy address
self._community.create_candidate(address, True, address, address, u"unknown")
def do_callback(self, key, *args, **kwargs):
if self._api_callback is not None:
self._api_callback(key, *args, **kwargs)
def verify_addresses_are_free(addrs):
if not addrs: # None or []
logger.warning("No address to return!")
return addrs
l = set() # No doubles!
for addr in addrs:
if not addr.resolve_interface():
logger.debug("Interface for %s does not exist", addr)
elif not try_sockets([addr]):
logger.debug("Port %s is not available for %s on %s", addr.port, addr.ip, addr.interface.name)
addr.set_port(0) # Let the system decide
l.add(addr)
else:
l.add(addr)
logger.debug("Swift will listen to %s", [str(a) for a in l])
return list(l)
if __name__ == '__main__':
from src.main import main
args, kwargs = main()
d = DispersyInstance(*args, **kwargs)
d.start()