def test_submodule_handler_definition_callable_decorator(self):
json_data = {
'modules': {
'root': {
'modules': {
'command': {
'args': [{
'long': '--foo'
}]
}
}
}
}
}
with open(DEFINITIONS_FILE, 'w') as f:
f.write(json.dumps(json_data))
parser_def = ParserDefinition('root.py')
@parser_def.callable('command')
def get_opts(opts):
return 'get_opts called: foo={}'.format(opts.foo)
argparser = parser_def.get_parser()
opts = argparser.parse_args(['command', '--foo', 'bar'])
expected = 'get_opts called: foo=bar'
self.assertEqual(opts.func(opts), expected)
def test_init_definitions_file_contains_correct_structure(self):
ParserDefinition.create('test_script.py', DEFINITIONS_FILE)
expected = {
'modules': {
'test_script': {
'examples': [],
'args': []
}
}
}
self.assertDictEqual(argutil.load(DEFINITIONS_FILE), expected)
def setUpClass(cls):
cls.filepath = 'test_script.py'
cls.module = argutil.get_module(cls.filepath)
cls.env = {
'l_str': lambda s: str(s).lower(),
}
with argutil.WorkingDirectory(WD):
parser_def = ParserDefinition.create(cls.filepath)
def add_arg(name, **kwargs):
return parser_def.add_argument(name, **kwargs)
add_arg('positional')
add_arg('positional_list', nargs='*', type=int)
add_arg('--flag', action='store_true', help='boolean flag option')
add_arg('--opt', short='-o', type='int')
add_arg('--opt-list', nargs='+', type=str)
add_arg('--opt-list-with-default', nargs='+', default=[])
add_arg('--env-type', type='l_str')
parser_def.env['hex'] = lambda s: hex(int(s))
add_arg('--def-env-type', type='hex')
argutil.GLOBAL_ENV['u_str'] = lambda s: s.upper()
add_arg('--global-env-type', type='u_str')
add_arg('--default-from-file')
parser_def.add_example('test --flag',
'positional w/ optional flag')
parser_def.set_defaults(default_from_file=123)
cls.parser = parser_def.get_parser(env=cls.env)
def test_delete_removes_definition(self):
parser_def = ParserDefinition.create('test_script.py')
json_data = argutil.load(parser_def.definitions_file)
self.assertIn(parser_def.module, json_data['modules'])
parser_def.delete()
json_data = argutil.load(parser_def.definitions_file)
self.assertNotIn(parser_def.module, json_data['modules'])
def test_delete_removes_defaults(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.add_argument('--foo')
parser_def.set_defaults(foo='bar')
json_data = argutil.load(parser_def.defaults_file)
self.assertIn(parser_def.module, json_data)
parser_def.delete()
json_data = argutil.load(parser_def.defaults_file)
self.assertNotIn(parser_def.module, json_data)
def test_submodule_option_defaults(self):
json_data = {
'modules': {
'root': {
'modules': {
'command': {
'args': [{
'long': '--foo'
}]
}
}
}
}
}
with open(DEFINITIONS_FILE, 'w') as f:
f.write(json.dumps(json_data))
parser_def = ParserDefinition('root.py')
parser = parser_def.get_parser()
opts = parser.parse_args(['command'])
self.assertIsNone(opts.foo)
parser_def.set_defaults(**{'command.foo': 'bar'})
parser = parser_def.get_parser()
opts = parser.parse_args(['command'])
self.assertEqual(opts.foo, 'bar')
def test_create_appends_to_existing_definitions_file(self):
base_data = {
'modules': {
'existing_module': {
'examples': [],
'args': []
}
}
}
self.create_json_file(DEFINITIONS_FILE, base_data)
ParserDefinition.create('test_script.py', DEFINITIONS_FILE)
expected = {
'modules': {
'existing_module': {
'examples': [],
'args': []
},
'test_script': {
'examples': [],
'args': []
}
}
}
self.assertDictEqual(argutil.load(DEFINITIONS_FILE), expected)
def test_config_multiple_properties(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.config([
"a=1", "b='2'", 'c="3"', "d=true", 'e=9.2', "f='false'", "g=False",
"h=None", "i=null"
])
expected = dict(a=1,
b='2',
c='3',
d=True,
e=9.2,
f='false',
g=False,
h=None,
i=None)
self.assertDictEqual(parser_def.get_defaults(), expected)
def test_error_missing_long_key(self):
filename = 'bad_module.py'
parser_def = ParserDefinition.create(filename)
json_data = {
'modules': {
'bad_module': {
'examples': [],
'args': [{
'help': ['no help for you']
}]
}
}
}
argutil.save(json_data, DEFINITIONS_FILE)
with self.assertRaises(ValidationError):
parser_def.get_parser()
import argutil
from argutil import (
ParserDefinition,
WorkingDirectory
)
from datetime import datetime
import os
import sys
from fnmatch import fnmatch
from .repl import Repl
parser_def = ParserDefinition()
argparser = None
def get_defaults():
return [
line.replace('init.', '')
for line in parser_def.config()
]
def get_defaults_map():
return {
parts[0]: '='.join(parts[1:])
for parts in (
line.split('=') for line in get_defaults()
)
}
def test_get_defaults_nonexistent_module(self):
expected = {}
parser_def = ParserDefinition.create('test_script.py')
parser_def.set_defaults(foo='bar')
parser_def2 = ParserDefinition.create('other_script.py')
self.assertDictEqual(parser_def2.get_defaults(), expected)
def test_init_error_on_bad_definitions_file(self):
self.create_json_file(DEFINITIONS_FILE, {})
with self.assertRaises(ValidationError):
ParserDefinition.create('test_script.py', DEFINITIONS_FILE)
def test_get_defaults_nonexistent_defaults_file(self):
parser_def = ParserDefinition.create('test_script.py')
self.assertDictEqual(parser_def.get_defaults(), {})
def test_init_nonexistent_module(self):
with self.assertRaises(SystemExit):
ParserDefinition('test_script.py').get_parser()
def test_get_defaults_existing_entries(self):
expected = {'foo': 'bar', 'bar2': 'foo2'}
parser_def = ParserDefinition.create('test_script.py')
parser_def.set_defaults(foo='bar', bar2='foo2')
self.assertDictEqual(parser_def.get_defaults(), expected)
def test_create_error_existing_module(self):
filename = 'test_script.py'
argutil.ParserDefinition.create(filename)
with self.assertRaises(KeyError):
ParserDefinition.create(filename)
def test_config_single_property(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.config(['foo=bar'])
expected = {'foo': 'bar'}
self.assertDictEqual(parser_def.get_defaults(), expected)
def test_config_has_nested_defaults(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.set_defaults(**{"foo.bar.fee": "bar"})
current = parser_def.config()
expected = ['foo.bar.fee=bar']
self.assertCollectionEqual(current, expected)
def test_config_fetch_has_defaults(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.set_defaults(foo='bar', bar='foo')
current = parser_def.config()
expected = ['foo=bar', 'bar=foo']
self.assertCollectionEqual(current, expected)
def test_config_fetch_no_defaults(self):
parser_def = ParserDefinition.create('test_script.py')
current = parser_def.config()
expected = []
self.assertEqual(current, expected)
def test_error_unknown_type(self):
filename = 'bad_module.py'
parser_def = ParserDefinition.create(filename)
parser_def.add_argument('unknown_type', type='shoe')
with self.assertRaises(KeyError):
parser_def.get_parser()
def test_set_defaults_creates_file_if_nonexistent(self):
self.assertIs(os.path.isfile(DEFAULTS_FILE), False)
ParserDefinition.create('test_script.py').set_defaults()
self.assertIs(os.path.isfile(DEFAULTS_FILE), True)
def test_config_list_property(self):
parser_def = ParserDefinition.create('test_script.py')
parser_def.config(['foo=[1, "2", \'3\', true, false, none, null]'])
expected = {'foo': [1, '2', '3', True, False, None, None]}
self.assertDictEqual(parser_def.get_defaults(), expected)
def test_get_defaults(self):
expected = {}
parser_def = ParserDefinition.create('test_script.py')
parser_def.set_defaults()
self.assertDictEqual(parser_def.get_defaults(), expected)