class BaseFormatterTest(object):
    prefix = ()
    suffix = ('\n', )

    def setUp(self):
        self.fakeout = FakeStreamFormatter()
        self.fakeerr = FakeStreamFormatter()
        self.formatter = self.newFormatter()

    @property
    def verify_formatterClass(self):
        class state_verifying_class(self.formatterClass):
            def format(internal_self, *args, **kwds):
                autoline = self.fakeout.autoline
                try:
                    ret = self.formatterClass.format(internal_self, *args,
                                                     **kwds)
                except Exception as e:
                    self.assertEqual(
                        autoline,
                        self.fakeout.autoline,
                        msg="exception thrown %s, autoline was %s, now is %s" %
                        (e, autoline, self.fakeout.autoline))
                    raise
                self.assertEqual(autoline,
                                 self.fakeout.autoline,
                                 msg="autoline was %s, now is %s" %
                                 (autoline, self.fakeout.autoline))
                return ret

        return state_verifying_class

    def newFormatter(self, **kwargs):
        disable_method_checks = kwargs.pop("disable_method_checks", False)
        kwargs.setdefault("out", self.fakeout)
        kwargs.setdefault("err", self.fakeerr)
        if not disable_method_checks:
            kls = self.verify_formatterClass
        else:
            kls = self.formatterClass
        return kls(**kwargs)

    def assertOut(self, *args, **kwargs):

        stringlist = []
        objectlist = []

        args = list(args)

        prefix = kwargs.setdefault("prefix", self.prefix)
        if isinstance(prefix, tuple):
            args = list(prefix) + args
        elif isinstance(prefix, list):
            args = prefix + args
        else:
            args.insert(0, prefix)

        suffix = kwargs.setdefault("suffix", self.suffix)
        if isinstance(suffix, tuple):
            args = args + list(suffix)
        elif isinstance(suffix, list):
            args = args + suffix
        else:
            args.append(suffix)

        for arg in args:
            if isinstance(arg, unicode):
                stringlist.append(arg.encode('ascii'))
            elif isinstance(arg, bytes):
                stringlist.append(arg)
            else:
                objectlist.append(b''.join(stringlist))
                stringlist = []
                objectlist.append(arg)
        objectlist.append(b''.join(stringlist))

        # Hack because a list with an empty string in is True
        if objectlist == [b'']:
            objectlist = []

        self.assertEqual(
            self.fakeout.stream, objectlist, '\n' + '\n'.join(
                difflib.unified_diff(list(repr(s) for s in objectlist),
                                     list(
                                         repr(s) for s in self.fakeout.stream),
                                     'expected',
                                     'actual',
                                     lineterm='')))
        self.fakeout.resetstream()

    def test_end(self):
        # Sub-classes should override this if they print something in end()
        self.formatter.format(FakeOp(FakeMutatedPkg('dev-util/diffball-1.1')))
        self.fakeout.resetstream()
        self.formatter.end()
        self.assertOut(suffix=())
 def setUp(self):
     self.fakeout = FakeStreamFormatter()
     self.fakeerr = FakeStreamFormatter()
     self.formatter = self.newFormatter()
Exemple #3
0
class TestUserQuery:
    @pytest.fixture(autouse=True)
    def __setup(self):
        self.out = FakeStreamFormatter()
        self.err = FakeStreamFormatter()
        self.query = partial(userquery, out=self.out, err=self.err)

    def test_default_answer(self, mocked_input):
        mocked_input.return_value = ''
        assert self.query('foo') == True

    def test_tuple_prompt(self, mocked_input):
        mocked_input.return_value = ''
        prompt = 'perhaps a tuple'
        assert self.query(tuple(prompt.split())) == True
        output = ''.join(prompt.split())
        assert self.out.get_text_stream().strip().split(
            '\n')[0][:len(output)] == output

    def test_no_default_answer(self, mocked_input):
        responses = {
            'a': ('z', 'Yes'),
            'b': ('y', 'No'),
        }
        # no default answer returns None for empty input
        mocked_input.return_value = ''
        assert self.query('foo', responses=responses) == None
        mocked_input.return_value = 'a'
        assert self.query('foo', responses=responses) == 'z'
        mocked_input.return_value = 'b'
        assert self.query('foo', responses=responses) == 'y'

    def test_ambiguous_input(self, mocked_input):
        responses = {
            'a': ('z', 'Yes'),
            'A': ('y', 'No'),
        }
        mocked_input.return_value = 'a'
        with pytest.raises(NoChoice):
            self.query('foo', responses=responses)
        error_output = self.err.get_text_stream().strip().split('\n')[1]
        expected = 'Response %r is ambiguous (%s)' % (
            mocked_input.return_value, ', '.join(sorted(responses.keys())))
        assert error_output == expected

    def test_default_correct_input(self, mocked_input):
        for input, output in (('no', False), ('No', False), ('yes', True),
                              ('Yes', True)):
            mocked_input.return_value = input
            assert self.query('foo') == output

    def test_default_answer_no_matches(self, mocked_input):
        mocked_input.return_value = ''
        with pytest.raises(ValueError):
            self.query('foo', default_answer='foo')
        assert self.out.stream == []

    def test_custom_default_answer(self, mocked_input):
        mocked_input.return_value = ''
        assert self.query('foo', default_answer=False) == False

    def test_eof_nochoice(self, mocked_input):
        # user hits ctrl-d
        mocked_input.side_effect = EOFError
        with pytest.raises(NoChoice):
            self.query('foo')
        output = self.out.get_text_stream().strip().split('\n')[1]
        expected = 'Not answerable: EOF on STDIN'
        assert output == expected

    def test_stdin_closed_nochoice(self, mocked_input):
        mocked_input.side_effect = IOError(errno.EBADF, '')
        with pytest.raises(NoChoice):
            self.query('foo')
        output = self.out.get_text_stream().strip().split('\n')[1]
        expected = 'Not answerable: STDIN is either closed, or not readable'
        assert output == expected

    def test_unhandled_ioerror(self, mocked_input):
        mocked_input.side_effect = IOError(errno.ENODEV, '')
        with pytest.raises(IOError):
            self.query('foo')

    def test_bad_choice_limit(self, mocked_input):
        # user hits enters a bad choice 3 times in a row
        mocked_input.return_value = 'bad'
        with pytest.raises(NoChoice):
            self.query('foo')
        assert mocked_input.call_count == 3
        output = self.err.get_text_stream().strip().split('\n')[1]
        expected = "Sorry, response %r not understood." % (
            mocked_input.return_value, )
        assert output == expected

    def test_custom_choice_limit(self, mocked_input):
        # user hits enters a bad choice 5 times in a row
        mocked_input.return_value = 'haha'
        with pytest.raises(NoChoice):
            self.query('foo', limit=5)
        assert mocked_input.call_count == 5
        output = self.err.get_text_stream().strip().split('\n')[1]
        expected = "Sorry, response %r not understood." % (
            mocked_input.return_value, )
        assert output == expected
Exemple #4
0
 def __setup(self):
     self.out = FakeStreamFormatter()
     self.err = FakeStreamFormatter()
     self.query = partial(userquery, out=self.out, err=self.err)
Exemple #5
0
 def __setup(self, mocker):
     self.input = mocker.patch('builtins.input')
     self.out = FakeStreamFormatter()
     self.err = FakeStreamFormatter()
     self.query = partial(userquery, out=self.out, err=self.err)
Exemple #6
0
class TestUserQuery(object):

    @pytest.fixture(autouse=True)
    def __setup(self, mocker):
        self.input = mocker.patch('builtins.input')
        self.out = FakeStreamFormatter()
        self.err = FakeStreamFormatter()
        self.query = partial(userquery, out=self.out, err=self.err)

    def test_default_answer(self):
        self.input.return_value = ''
        assert self.query('foo') == True

    def test_tuple_prompt(self):
        self.input.return_value = ''
        prompt = 'perhaps a tuple'
        assert self.query(tuple(prompt.split())) == True
        output = ''.join(prompt.split())
        assert self.out.get_text_stream().strip().split('\n')[0][:len(output)] == output

    def test_no_default_answer(self):
        responses = {
            'a': ('z', 'Yes'),
            'b': ('y', 'No'),
        }
        # no default answer returns None for empty input
        self.input.return_value = ''
        assert self.query('foo', responses=responses) == None
        self.input.return_value = 'a'
        assert self.query('foo', responses=responses) == 'z'
        self.input.return_value = 'b'
        assert self.query('foo', responses=responses) == 'y'

    def test_ambiguous_input(self):
        responses = {
            'a': ('z', 'Yes'),
            'A': ('y', 'No'),
        }
        self.input.return_value = 'a'
        with pytest.raises(NoChoice):
            self.query('foo', responses=responses)
        error_output = self.err.get_text_stream().strip().split('\n')[1]
        expected = 'Response %r is ambiguous (%s)' % (
            self.input.return_value, ', '.join(sorted(responses.keys())))
        assert error_output == expected

    def test_default_correct_input(self):
        for input, output in (('no', False),
                            ('No', False),
                            ('yes', True),
                            ('Yes', True)):
            self.input.return_value = input
            assert self.query('foo') == output

    def test_default_answer_no_matches(self):
        self.input.return_value = ''
        with pytest.raises(ValueError):
            self.query('foo', default_answer='foo')
        assert self.out.stream == []

    def test_custom_default_answer(self):
        self.input.return_value = ''
        assert self.query('foo', default_answer=False) == False

    def test_eof_nochoice(self):
        # user hits ctrl-d
        self.input.side_effect = EOFError
        with pytest.raises(NoChoice):
            self.query('foo')
        output = self.out.get_text_stream().strip().split('\n')[1]
        expected = 'Not answerable: EOF on STDIN'
        assert output == expected

    def test_stdin_closed_nochoice(self):
        self.input.side_effect = IOError(errno.EBADF, '')
        with pytest.raises(NoChoice):
            self.query('foo')
        output = self.out.get_text_stream().strip().split('\n')[1]
        expected = 'Not answerable: STDIN is either closed, or not readable'
        assert output == expected

    def test_unhandled_ioerror(self):
        self.input.side_effect = IOError(errno.ENODEV, '')
        with pytest.raises(IOError):
            self.query('foo')

    def test_bad_choice_limit(self):
        # user hits enters a bad choice 3 times in a row
        self.input.return_value = 'bad'
        with pytest.raises(NoChoice):
            self.query('foo')
        assert self.input.call_count == 3
        output = self.err.get_text_stream().strip().split('\n')[1]
        expected = "Sorry, response %r not understood." % (self.input.return_value,)
        assert output == expected

    def test_custom_choice_limit(self):
        # user hits enters a bad choice 5 times in a row
        self.input.return_value = 'haha'
        with pytest.raises(NoChoice):
            self.query('foo', limit=5)
        assert self.input.call_count == 5
        output = self.err.get_text_stream().strip().split('\n')[1]
        expected = "Sorry, response %r not understood." % (self.input.return_value,)
        assert output == expected
Exemple #7
0
 def __setup(self, mocker):
     self.input = mocker.patch('builtins.input')
     self.out = FakeStreamFormatter()
     self.err = FakeStreamFormatter()
     self.query = partial(userquery, out=self.out, err=self.err)
Exemple #8
0
 def setUp(self):
     self.fakeout = FakeStreamFormatter()
     self.fakeerr = FakeStreamFormatter()
     self.formatter = self.newFormatter()
Exemple #9
0
class BaseFormatterTest(object):
    prefix = ()
    suffix = ('\n',)
    def setUp(self):
        self.fakeout = FakeStreamFormatter()
        self.fakeerr = FakeStreamFormatter()
        self.formatter = self.newFormatter()

    @property
    def verify_formatterClass(self):
        class state_verifying_class(self.formatterClass):
            def format(internal_self, *args, **kwds):
                autoline = self.fakeout.autoline
                try:
                    ret = self.formatterClass.format(internal_self, *args, **kwds)
                except Exception as e:
                    self.assertEqual(autoline, self.fakeout.autoline, msg=
                        "exception thrown %s, autoline was %s, now is %s" % (e, autoline, self.fakeout.autoline))
                    raise
                self.assertEqual(autoline, self.fakeout.autoline, msg=
                    "autoline was %s, now is %s" % (autoline, self.fakeout.autoline))
                return ret
        return state_verifying_class

    def newFormatter(self, **kwargs):
        disable_method_checks = kwargs.pop("disable_method_checks", False)
        kwargs.setdefault("out", self.fakeout)
        kwargs.setdefault("err", self.fakeerr)
        if not disable_method_checks:
            kls = self.verify_formatterClass
        else:
            kls = self.formatterClass
        return kls(**kwargs)

    def assertOut(self, *args, **kwargs):

        stringlist = []
        objectlist = []

        args = list(args)

        prefix = kwargs.setdefault("prefix", self.prefix)
        if isinstance(prefix, tuple):
            args = list(prefix) + args
        elif isinstance(prefix, list):
            args = prefix + args
        else:
            args.insert(0, prefix)

        suffix = kwargs.setdefault("suffix", self.suffix)
        if isinstance(suffix, tuple):
            args = args + list(suffix)
        elif isinstance(suffix, list):
            args = args + suffix
        else:
            args.append(suffix)

        for arg in args:
            if isinstance(arg, unicode):
                stringlist.append(arg.encode('ascii'))
            elif isinstance(arg, bytes):
                stringlist.append(arg)
            else:
                objectlist.append(b''.join(stringlist))
                stringlist = []
                objectlist.append(arg)
        objectlist.append(b''.join(stringlist))

        # Hack because a list with an empty string in is True
        if objectlist == [b'']:
            objectlist = []

        self.assertEqual(self.fakeout.stream, objectlist, '\n' + '\n'.join(
                difflib.unified_diff(
                    list(repr(s) for s in objectlist),
                    list(repr(s) for s in self.fakeout.stream),
                    'expected', 'actual', lineterm='')))
        self.fakeout.resetstream()

    def test_end(self):
        # Sub-classes should override this if they print something in end()
        self.formatter.format(FakeOp(FakeMutatedPkg('dev-util/diffball-1.1')))
        self.fakeout.resetstream()
        self.formatter.end()
        self.assertOut(suffix=())