def test_options(self):
class TestDeclarative(Command):
spam = Option('a', 'asomething')
eggs = Option('b', 'bsomething')
a = TestDeclarative()
b = Command(options={
'spam': Option('a', 'asomething'),
'eggs': Option('b', 'bsomething')
})
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo']), ({
'c': ({
'spam': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--asomething', u'foo']), ({
'c': ({
'spam': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'-b', u'foo']), ({
'c': ({
u'eggs': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--bsomething', u'foo']), ({
'c': ({
u'eggs': u'foo'
}, [])
}, []))
def test_evaluate(self):
o = BooleanOption(short="b")
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate([u'-b']), ({'b': True}, []))
o = BooleanOption(short="b", default=True)
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate(['-b']), ({'b': False}, []))
def test_options(self):
class TestDeclarative(Command):
spam = Option('a', 'asomething')
eggs = Option('b', 'bsomething')
a = TestDeclarative()
b = Command(options={
'spam': Option('a', 'asomething'),
'eggs': Option('b', 'bsomething')})
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo']),
({'c': ({'spam': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--asomething', u'foo']),
({'c': ({'spam': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-b', u'foo']),
({'c': ({u'eggs': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--bsomething', u'foo']),
({'c': ({u'eggs': u'foo'}, [])}, [])
)
def test_evaluate(self):
o = BooleanOption(short="b")
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate([u'-b']), ({'b': True}, []))
o = BooleanOption(short="b", default=True)
p = Parser(options=dict(b=o))
self.assertEqual(p.evaluate(['-b']), ({'b': False}, []))
def test_evaluate_with_quotes(self):
o = MultipleOptions(short='o')
p = Parser(options=dict(o=o))
self.assertEqual(p.evaluate([u'-o', u'foo,"bar,baz"']), ({
'o': [u'foo', u'bar,baz']
}, []))
self.assertEqual(p.evaluate([u'-o', u'"foo,bar",baz']), ({
'o': [u'foo,bar', u'baz']
}, []))
def test_evaluate_with_quotes(self):
o = MultipleOptions(short='o')
p = Parser(options=dict(o=o))
self.assertEqual(
p.evaluate([u'-o', u'foo,"bar,baz"']),
({'o': [u'foo', u'bar,baz']}, [])
)
self.assertEqual(
p.evaluate([u'-o', u'"foo,bar",baz']),
({'o': [u'foo,bar', u'baz']}, [])
)
def test_dynamically_adding_nodes(self):
p = Parser()
p.commands['foo'] = Command()
p.commands['foo'].options['a'] = BooleanOption('a')
p.options['bar'] = Option('b')
self.assertEquals(p.evaluate([u'-b', u'spam']), ({'bar': u'spam'}, []))
self.assertEquals(
p.evaluate([u'foo']),
({'foo': ({'a': False}, [])}, [])
)
self.assertEquals(
p.evaluate([u'foo', u'-a']),
({'foo': ({'a': True}, [])}, [])
)
def test_remaining_arguments(self):
c = Command(options={'a': Option('a')})
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'foo']),
({'c': ({}, [u'foo'])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo']),
({'c': ({'a': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'-a', u'foo', u'bar']),
({u'c': ({'a': u'foo'}, [u'bar'])}, [])
)
def test_remaining_arguments(self):
c = Command(options={'a': Option('a')})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'foo']), ({
'c': ({}, [u'foo'])
}, []))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo']), ({
'c': ({
'a': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'-a', u'foo', u'bar']), ({
u'c': ({
'a': u'foo'
}, [u'bar'])
}, []))
def test_disallow_abbreviated_commands(self):
class NewCommand(Command):
allow_abbreviated_commands = False
c = NewCommand(commands={'foo': Command()})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'f']), ({'c': ({}, [u'f'])}, []))
def test_default_evaluate_arguments(self):
old_argv = sys.argv
enc = sys.stdin.encoding or sys.getdefaultencoding()
sys.argv = [s.encode(enc) for s in [u'script_name', u'foo', u'bar']]
p = Parser()
self.assertEqual(p.evaluate(), ({}, [u'foo', u'bar']))
sys.argv = old_argv
def test_default_evaluate_arguments(self):
old_argv = sys.argv
enc = sys.stdin.encoding or sys.getdefaultencoding()
sys.argv = [s.encode(enc) for s in [u'script_name', u'foo', u'bar']]
p = Parser()
self.assertEqual(p.evaluate(), ({}, [u'foo', u'bar']))
sys.argv = old_argv
def test_dynamically_adding_nodes(self):
p = Parser()
p.commands['foo'] = Command()
p.commands['foo'].options['a'] = BooleanOption('a')
p.options['bar'] = Option('b')
self.assertEquals(p.evaluate([u'-b', u'spam']), ({'bar': u'spam'}, []))
self.assertEquals(p.evaluate([u'foo']), ({
'foo': ({
'a': False
}, [])
}, []))
self.assertEquals(p.evaluate([u'foo', u'-a']), ({
'foo': ({
'a': True
}, [])
}, []))
def test_disallow_abbreviated_commands(self):
class NewCommand(Command):
allow_abbreviated_commands = False
c = NewCommand(commands={
'foo': Command()
})
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'f']), ({'c': ({}, [u'f'])}, []))
def test_commands(self):
class TestDeclarative(Command):
spam = Command()
eggs = Command()
a = TestDeclarative()
b = Command(commands={
'spam': Command(),
'eggs': Command()})
cp = [u'script_name']
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(
p.evaluate([u'c', u'spam']),
({'c': ({u'spam': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'eggs']),
({'c': ({'eggs': ({}, [])}, [])}, [])
)
def test_commands(self):
class TestDeclarative(Command):
spam = Command()
eggs = Command()
a = TestDeclarative()
b = Command(commands={'spam': Command(), 'eggs': Command()})
cp = [u'script_name']
for c in [a, b]:
p = Parser(commands=dict(c=c))
self.assertEqual(p.evaluate([u'c', u'spam']), ({
'c': ({
u'spam': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'eggs']), ({
'c': ({
'eggs': ({}, [])
}, [])
}, []))
def test_abbreviations(self):
c = Command(
options={
'stack': Option(long='stack'),
'stash': Option(long='stash')},
commands={
'stack': Command(),
'stash': Command()})
p = Parser(commands=dict(c=c))
cp = [u'script_name']
for s in [u's', u'st', u'sta']:
cmd = [u'c', s]
result = ({'c': ({}, [s])}, [])
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(
p.evaluate([u'c', u'stac']),
({'c': ({u'stack': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'stas']),
({'c': ({u'stash': ({}, [])}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--stac', u'foo']),
({'c': ({u'stack': u'foo'}, [])}, [])
)
self.assertEqual(
p.evaluate([u'c', u'--stas', u'foo']),
({'c': ({u'stash': u'foo'}, [])}, [])
)
def test_abbreviations(self):
c = Command(options={
'stack': Option(long='stack'),
'stash': Option(long='stash')
},
commands={
'stack': Command(),
'stash': Command()
})
p = Parser(commands=dict(c=c))
cp = [u'script_name']
for s in [u's', u'st', u'sta']:
cmd = [u'c', s]
result = ({'c': ({}, [s])}, [])
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate(cmd), result)
self.assertEqual(p.evaluate([u'c', u'stac']), ({
'c': ({
u'stack': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'stas']), ({
'c': ({
u'stash': ({}, [])
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--stac', u'foo']), ({
'c': ({
u'stack': u'foo'
}, [])
}, []))
self.assertEqual(p.evaluate([u'c', u'--stas', u'foo']), ({
'c': ({
u'stash': u'foo'
}, [])
}, []))
def make_test(self, range, p):
parser = Parser(positionals=[p])
for i in range:
self.assertEqual(parser.evaluate([unicode(i)]), ({}, [i]))
def make_test(self, range, o):
p = Parser(options=dict(o=o))
for i in range:
self.assertEqual(p.evaluate([u'-o', unicode(i)]), ({'o': i}, []))
def make_test(self, range, p):
parser = Parser(positionals=[p])
for i in range:
self.assertEqual(parser.evaluate([unicode(i)]), ({}, [i]))
def make_test(self, range, o):
p = Parser(options=dict(o=o))
for i in range:
self.assertEqual(p.evaluate([u'-o', unicode(i)]), ({'o': i}, []))
def test_evaluate(self):
p = Parser(positionals=[Positional('foo')])
self.assertEquals(p.evaluate([u'spam']), ({}, [u'spam']))
parser = Parser(description=u"Mail autoresponse filter for postfix", options={
"sender": Option("s", "sender",
short_description=u"Sender of the mail"),
"user": Option("r", "recipient",
short_description=u"Recipient of the mail"),
"sasl": Option("S", "sasl-username",
short_description=u"SASL username"),
"clientIP": Option("i", "client-ip",
short_description=u"Client IP address (optional))"),
"configFile": Option("c", "config",
short_description=u"Config file to read (default '/etc/autoresponder.conf')",
default="/etc/autoresponder.conf")
})
# parse command line
settings, arguments = parser.evaluate()
if (len(settings.keys()) == 0):
parser.evaluate(["help"])
# user name
try:
userName = settings["user"]
except KeyError:
print "You have to define a user by using -r or --recipient"
exit(1)
# open config file
configFile = settings["configFile"]
config = ConfigParser.SafeConfigParser()
config.read(configFile)
try:
def test_evaluate(self):
p = Parser(positionals=[Positional('foo')])
self.assertEquals(p.evaluate([u'spam']), ({}, [u'spam']))
