def test_delimiters_type(self):
self.assertFalse(Rule().delimiter(DoubleDelimiter())(self.p))
self.assertFalse(Rule().delimiter(SingleDelimiter())(
self.with_double_delimiter))
self.assertTrue(Rule().delimiter(SingleDelimiter())(self.p))
self.assertTrue(Rule().delimiter(DoubleDelimiter())(
self.with_double_delimiter))
def test_delimiters_position(self):
self.assertFalse(Rule().delimiter(DoubleDelimiter(2))(self.p))
self.assertFalse(Rule().delimiter(SingleDelimiter(2))(
self.with_double_delimiter))
self.assertTrue(Rule().delimiter(SingleDelimiter(1))(self.p))
self.assertTrue(Rule().delimiter(DoubleDelimiter(1))(
self.with_double_delimiter))
def _rules(self):
return create('extended rule').extended()\
.statement('flag', result=self.hook,
rule=Rule().empty(Data.Delimiter)
.empty(Data.Target)
.option('flag'))\
.info('second info message\nmultiline')\
.statement('target', result=self.another_hook,
rule=Rule().empty(Data.Delimiter)
.empty(Data.Option)
.size(Data.Target, Op.eq(1)))\
.product()
def test_complex2(self):
p = Params(['target', '--key=value'])
s = Statement(
'message', RESULT,
Rule().option('key',
'value').empty(Data.Delimiter).target('target', 0))
self.assertEqual(s.attempt(p), RESULT)
def test_complex1(self):
p = Params(['target', '--', '--flag', '--key=value'])
s = Statement('message',
RESULT,
rule=Rule().delimiter(
DoubleDelimiter()).option('flag').option(
'key', 'value').target('target', 0))
self.assertEqual(s.attempt(p), RESULT)
def test_has(self):
self.assertTrue(Rule().has(Data.Target, 'target')(self.p))
self.assertTrue(Rule().has(Data.Delimiter, SingleDelimiter())(self.p))
self.assertTrue(Rule().has(Data.Option, 'key')(self.p))
self.assertFalse(Rule().has(Data.Target, 'target1')(self.p))
self.assertFalse(Rule().has(Data.Delimiter, DoubleDelimiter())(self.p))
self.assertFalse(Rule().has(Data.Option, 'missing_key')(self.p))
def test_not_empty(self):
self.assertFalse(Rule().not_empty(Data.Target)(Params([])))
self.assertFalse(Rule().not_empty(Data.Delimiter)(Params([])))
self.assertFalse(Rule().not_empty(Data.Option)(Params([])))
self.assertTrue(Rule().not_empty(Data.Target)(self.p))
self.assertTrue(Rule().not_empty(Data.Delimiter)(self.p))
self.assertTrue(Rule().not_empty(Data.Option)(self.p))
def test_size(self):
self.assertTrue(Rule().size(Data.Target, Op.eq(1))(self.p))
self.assertTrue(Rule().size(Data.Delimiter, Op.eq(1))(self.p))
self.assertTrue(Rule().size(Data.Option, Op.eq(2))(self.p))
self.assertFalse(Rule().size(Data.Target, Op.eq(2))(self.p))
self.assertFalse(Rule().size(Data.Delimiter, Op.eq(2))(self.p))
self.assertFalse(Rule().size(Data.Option, Op.eq(1))(self.p))
def test_option(self):
self.assertTrue(Rule().option('flag')(self.p))
self.assertTrue(Rule().option('key', 'value')(self.p))
self.assertTrue(Rule().option('key', 'value', 'value2')(self.p))
self.assertFalse(Rule().option('flag', 'some_value')(self.p))
self.assertFalse(Rule().option('key', 'value2')(self.p))
self.assertFalse(Rule().option('key1')(self.p))
def test_target(self):
self.assertTrue(Rule().target('target', 0)(self.p))
self.assertFalse(Rule().target('target_wrong', 0)(self.p))
self.assertFalse(Rule().target('target', 1)(self.p))
def empty_command(self, result):
return [Statement(self._messages, result,
rule=Rule().empty(Data.Delimiter)
.empty(Data.Option)
.empty(Data.Target))]
def single_option_command(self, result):
return [Statement(self._messages, result,
rule=Rule().empty(Data.Delimiter)
.empty(Data.Option)
.size(Data.Target, Op.eq(1)))]