#!/usr/bin/python

#

# Test suite for Optik.  Supplied by Johannes Gijsbers

# (taradino@softhome.net) -- translated from the original Optik

# test suite to this PyUnit-based version.

#

# $Id: test_optparse.py 61000 2008-02-23 17:40:11Z christian.heimes $

#

import sys

import os

import re

import copy

import types

import unittest

from StringIO import StringIO

from test import test_support

from optparse import make_option, Option, IndentedHelpFormatter, \

     TitledHelpFormatter, OptionParser, OptionContainer, OptionGroup, \

     SUPPRESS_HELP, SUPPRESS_USAGE, OptionError, OptionConflictError, \

     BadOptionError, OptionValueError, Values

from optparse import _match_abbrev

from optparse import _parse_num

# Do the right thing with boolean values for all known Python versions.

try:

    True, False

except NameError:

    (True, False) = (1, 0)

retype = type(re.compile(''))

class InterceptedError(Exception):

    def __init__(self,

                 error_message=None,

                 exit_status=None,

                 exit_message=None):

        self.error_message = error_message

        self.exit_status = exit_status

        self.exit_message = exit_message

    def __str__(self):

        return self.error_message or self.exit_message or "intercepted error"

class InterceptingOptionParser(OptionParser):

    def exit(self, status=0, msg=None):

        raise InterceptedError(exit_status=status, exit_message=msg)

    def error(self, msg):

        raise InterceptedError(error_message=msg)

class BaseTest(unittest.TestCase):

    def assertParseOK(self, args, expected_opts, expected_positional_args):

        """Assert the options are what we expected when parsing arguments.

        Otherwise, fail with a nicely formatted message.

        Keyword arguments:

        args -- A list of arguments to parse with OptionParser.

        expected_opts -- The options expected.

        expected_positional_args -- The positional arguments expected.

        Returns the options and positional args for further testing.

        """

        (options, positional_args) = self.parser.parse_args(args)

        optdict = vars(options)

        self.assertEqual(optdict, expected_opts,

                         """

Options are %(optdict)s.

Should be %(expected_opts)s.

Args were %(args)s.""" % locals())

        self.assertEqual(positional_args, expected_positional_args,

                         """

Positional arguments are %(positional_args)s.

Should be %(expected_positional_args)s.

Args were %(args)s.""" % locals ())

        return (options, positional_args)

    def assertRaises(self,

                     func,

                     args,

                     kwargs,

                     expected_exception,

                     expected_message):

        """

        Assert that the expected exception is raised when calling a

        function, and that the right error message is included with

        that exception.

        Arguments:

          func -- the function to call

          args -- positional arguments to `func`

          kwargs -- keyword arguments to `func`

          expected_exception -- exception that should be raised

          expected_message -- expected exception message (or pattern

            if a compiled regex object)

        Returns the exception raised for further testing.

        """

        if args is None:

            args = ()

        if kwargs is None:

            kwargs = {}

        try:

            func(*args, **kwargs)

        except expected_exception, err:

            actual_message = str(err)

            if isinstance(expected_message, retype):

                self.assert_(expected_message.search(actual_message),

                             """\

expected exception message pattern:

/%s/

actual exception message:

'''%s'''

""" % (expected_message.pattern, actual_message))

            else:

                self.assertEqual(actual_message,

                                 expected_message,

                                 """\

expected exception message:

'''%s'''

actual exception message:

'''%s'''

""" % (expected_message, actual_message))

            return err

        else:

            self.fail("""expected exception %(expected_exception)s not raised

called %(func)r

with args %(args)r

and kwargs %(kwargs)r

""" % locals ())

    # -- Assertions used in more than one class --------------------

    def assertParseFail(self, cmdline_args, expected_output):

        """

        Assert the parser fails with the expected message.  Caller

        must ensure that self.parser is an InterceptingOptionParser.

        """

        try:

            self.parser.parse_args(cmdline_args)

        except InterceptedError, err:

            self.assertEqual(err.error_message, expected_output)

        else:

            self.assertFalse("expected parse failure")

    def assertOutput(self,

                     cmdline_args,

                     expected_output,

                     expected_status=0,

                     expected_error=None):

        """Assert the parser prints the expected output on stdout."""

        save_stdout = sys.stdout

        encoding = getattr(save_stdout, 'encoding', None)

        try:

            try:

                sys.stdout = StringIO()

                if encoding:

                    sys.stdout.encoding = encoding

                self.parser.parse_args(cmdline_args)

            finally:

                output = sys.stdout.getvalue()

                sys.stdout = save_stdout

        except InterceptedError, err:

            self.assert_(

                type(output) is types.StringType,

                "expected output to be an ordinary string, not %r"

                % type(output))

            if output != expected_output:

                self.fail("expected: \n'''\n" + expected_output +

                          "'''\nbut got \n'''\n" + output + "'''")

            self.assertEqual(err.exit_status, expected_status)

            self.assertEqual(err.exit_message, expected_error)

        else:

            self.assertFalse("expected parser.exit()")

    def assertTypeError(self, func, expected_message, *args):

        """Assert that TypeError is raised when executing func."""

        self.assertRaises(func, args, None, TypeError, expected_message)

    def assertHelp(self, parser, expected_help):

        actual_help = parser.format_help()

        if actual_help != expected_help:

            raise self.failureException(

                'help text failure; expected:\n"' +

                expected_help + '"; got:\n"' +

                actual_help + '"\n')

# -- Test make_option() aka Option -------------------------------------

# It's not necessary to test correct options here.  All the tests in the

# parser.parse_args() section deal with those, because they're needed

# there.

class TestOptionChecks(BaseTest):

    def setUp(self):

        self.parser = OptionParser(usage=SUPPRESS_USAGE)

    def assertOptionError(self, expected_message, args=[], kwargs={}):

        self.assertRaises(make_option, args, kwargs,

                          OptionError, expected_message)

    def test_opt_string_empty(self):

        self.assertTypeError(make_option,

                             "at least one option string must be supplied")

    def test_opt_string_too_short(self):

        self.assertOptionError(

            "invalid option string 'b': must be at least two characters long",

            ["b"])

    def test_opt_string_short_invalid(self):

        self.assertOptionError(

            "invalid short option string '--': must be "

            "of the form -x, (x any non-dash char)",

            ["--"])

    def test_opt_string_long_invalid(self):

        self.assertOptionError(

            "invalid long option string '---': "

            "must start with --, followed by non-dash",

            ["---"])

    def test_attr_invalid(self):

        self.assertOptionError(

            "option -b: invalid keyword arguments: bar, foo",

            ["-b"], {'foo': None, 'bar': None})

    def test_action_invalid(self):

        self.assertOptionError(

            "option -b: invalid action: 'foo'",

            ["-b"], {'action': 'foo'})

    def test_type_invalid(self):

        self.assertOptionError(

            "option -b: invalid option type: 'foo'",

            ["-b"], {'type': 'foo'})

        self.assertOptionError(

            "option -b: invalid option type: 'tuple'",

            ["-b"], {'type': tuple})

    def test_no_type_for_action(self):

        self.assertOptionError(

            "option -b: must not supply a type for action 'count'",

            ["-b"], {'action': 'count', 'type': 'int'})

    def test_no_choices_list(self):

        self.assertOptionError(

            "option -b/--bad: must supply a list of "

            "choices for type 'choice'",

            ["-b", "--bad"], {'type': "choice"})

    def test_bad_choices_list(self):

        typename = type('').__name__

        self.assertOptionError(

            "option -b/--bad: choices must be a list of "

            "strings ('%s' supplied)" % typename,

            ["-b", "--bad"],

            {'type': "choice", 'choices':"bad choices"})

    def test_no_choices_for_type(self):

        self.assertOptionError(

            "option -b: must not supply choices for type 'int'",

            ["-b"], {'type': 'int', 'choices':"bad"})

    def test_no_const_for_action(self):

        self.assertOptionError(

            "option -b: 'const' must not be supplied for action 'store'",

            ["-b"], {'action': 'store', 'const': 1})

    def test_no_nargs_for_action(self):

        self.assertOptionError(

            "option -b: 'nargs' must not be supplied for action 'count'",

            ["-b"], {'action': 'count', 'nargs': 2})

    def test_callback_not_callable(self):

        self.assertOptionError(

            "option -b: callback not callable: 'foo'",

            ["-b"], {'action': 'callback',

                     'callback': 'foo'})

    def dummy(self):

        pass

    def test_callback_args_no_tuple(self):

        self.assertOptionError(

            "option -b: callback_args, if supplied, "

            "must be a tuple: not 'foo'",

            ["-b"], {'action': 'callback',

                     'callback': self.dummy,

                     'callback_args': 'foo'})

    def test_callback_kwargs_no_dict(self):

        self.assertOptionError(

            "option -b: callback_kwargs, if supplied, "

            "must be a dict: not 'foo'",

            ["-b"], {'action': 'callback',

                     'callback': self.dummy,

                     'callback_kwargs': 'foo'})

    def test_no_callback_for_action(self):

        self.assertOptionError(

            "option -b: callback supplied ('foo') for non-callback option",

            ["-b"], {'action': 'store',

                     'callback': 'foo'})

    def test_no_callback_args_for_action(self):

        self.assertOptionError(

            "option -b: callback_args supplied for non-callback option",

            ["-b"], {'action': 'store',

                     'callback_args': 'foo'})

    def test_no_callback_kwargs_for_action(self):

        self.assertOptionError(

            "option -b: callback_kwargs supplied for non-callback option",

            ["-b"], {'action': 'store',

                     'callback_kwargs': 'foo'})

class TestOptionParser(BaseTest):

    def setUp(self):

        self.parser = OptionParser()

        self.parser.add_option("-v", "--verbose", "-n", "--noisy",

                          action="store_true", dest="verbose")

        self.parser.add_option("-q", "--quiet", "--silent",

                          action="store_false", dest="verbose")

    def test_add_option_no_Option(self):

        self.assertTypeError(self.parser.add_option,

                             "not an Option instance: None", None)

    def test_add_option_invalid_arguments(self):

        self.assertTypeError(self.parser.add_option,

                             "invalid arguments", None, None)

    def test_get_option(self):

        opt1 = self.parser.get_option("-v")

        self.assert_(isinstance(opt1, Option))

        self.assertEqual(opt1._short_opts, ["-v", "-n"])

        self.assertEqual(opt1._long_opts, ["--verbose", "--noisy"])

        self.assertEqual(opt1.action, "store_true")

        self.assertEqual(opt1.dest, "verbose")

    def test_get_option_equals(self):

        opt1 = self.parser.get_option("-v")

        opt2 = self.parser.get_option("--verbose")

        opt3 = self.parser.get_option("-n")

        opt4 = self.parser.get_option("--noisy")

        self.assert_(opt1 is opt2 is opt3 is opt4)

    def test_has_option(self):

        self.assert_(self.parser.has_option("-v"))

        self.assert_(self.parser.has_option("--verbose"))

    def assert_removed(self):

        self.assert_(self.parser.get_option("-v") is None)

        self.assert_(self.parser.get_option("--verbose") is None)

        self.assert_(self.parser.get_option("-n") is None)

        self.assert_(self.parser.get_option("--noisy") is None)

        self.failIf(self.parser.has_option("-v"))

        self.failIf(self.parser.has_option("--verbose"))

        self.failIf(self.parser.has_option("-n"))

        self.failIf(self.parser.has_option("--noisy"))

        self.assert_(self.parser.has_option("-q"))

        self.assert_(self.parser.has_option("--silent"))

    def test_remove_short_opt(self):

        self.parser.remove_option("-n")

        self.assert_removed()

    def test_remove_long_opt(self):

        self.parser.remove_option("--verbose")

        self.assert_removed()

    def test_remove_nonexistent(self):

        self.assertRaises(self.parser.remove_option, ('foo',), None,

                          ValueError, "no such option 'foo'")

    def test_refleak(self):

        # If an OptionParser is carrying around a reference to a large

        # object, various cycles can prevent it from being GC'd in

        # a timely fashion.  destroy() breaks the cycles to ensure stuff

        # can be cleaned up.

        big_thing = [42]

        refcount = sys.getrefcount(big_thing)

        parser = OptionParser()

        parser.add_option("-a", "--aaarggh")

        parser.big_thing = big_thing

        parser.destroy()

        #self.assertEqual(refcount, sys.getrefcount(big_thing))

        del parser

        self.assertEqual(refcount, sys.getrefcount(big_thing))

class TestOptionValues(BaseTest):

    def setUp(self):

        pass

    def test_basics(self):

        values = Values()

        self.assertEqual(vars(values), {})

        self.assertEqual(values, {})

        self.assertNotEqual(values, {"foo": "bar"})

        self.assertNotEqual(values, "")

        dict = {"foo": "bar", "baz": 42}

        values = Values(defaults=dict)

        self.assertEqual(vars(values), dict)

        self.assertEqual(values, dict)

        self.assertNotEqual(values, {"foo": "bar"})

        self.assertNotEqual(values, {})

        self.assertNotEqual(values, "")

        self.assertNotEqual(values, [])

class TestTypeAliases(BaseTest):

    def setUp(self):

        self.parser = OptionParser()

    def test_str_aliases_string(self):

        self.parser.add_option("-s", type="str")

        self.assertEquals(self.parser.get_option("-s").type, "string")

    def test_new_type_object(self):

        self.parser.add_option("-s", type=str)

        self.assertEquals(self.parser.get_option("-s").type, "string")

        self.parser.add_option("-x", type=int)

        self.assertEquals(self.parser.get_option("-x").type, "int")

    def test_old_type_object(self):

        self.parser.add_option("-s", type=types.StringType)

        self.assertEquals(self.parser.get_option("-s").type, "string")

        self.parser.add_option("-x", type=types.IntType)

        self.assertEquals(self.parser.get_option("-x").type, "int")

# Custom type for testing processing of default values.

_time_units = { 's' : 1, 'm' : 60, 'h' : 60*60, 'd' : 60*60*24 }

def _check_duration(option, opt, value):

    try:

        if value[-1].isdigit():

            return int(value)

        else:

            return int(value[:-1]) * _time_units[value[-1]]

    except ValueError, IndexError:

        raise OptionValueError(

            'option %s: invalid duration: %r' % (opt, value))

class DurationOption(Option):

    TYPES = Option.TYPES + ('duration',)

    TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)

    TYPE_CHECKER['duration'] = _check_duration

class TestDefaultValues(BaseTest):

    def setUp(self):

        self.parser = OptionParser()

        self.parser.add_option("-v", "--verbose", default=True)

        self.parser.add_option("-q", "--quiet", dest='verbose')

        self.parser.add_option("-n", type="int", default=37)

        self.parser.add_option("-m", type="int")

        self.parser.add_option("-s", default="foo")

        self.parser.add_option("-t")

        self.parser.add_option("-u", default=None)

        self.expected = { 'verbose': True,

                          'n': 37,

                          'm': None,

                          's': "foo",

                          't': None,

                          'u': None }

    def test_basic_defaults(self):

        self.assertEqual(self.parser.get_default_values(), self.expected)

    def test_mixed_defaults_post(self):

        self.parser.set_defaults(n=42, m=-100)

        self.expected.update({'n': 42, 'm': -100})

        self.assertEqual(self.parser.get_default_values(), self.expected)

    def test_mixed_defaults_pre(self):

        self.parser.set_defaults(x="barf", y="blah")

        self.parser.add_option("-x", default="frob")

        self.parser.add_option("-y")

        self.expected.update({'x': "frob", 'y': "blah"})

        self.assertEqual(self.parser.get_default_values(), self.expected)

        self.parser.remove_option("-y")

        self.parser.add_option("-y", default=None)

        self.expected.update({'y': None})

        self.assertEqual(self.parser.get_default_values(), self.expected)

    def test_process_default(self):

        self.parser.option_class = DurationOption

        self.parser.add_option("-d", type="duration", default=300)

        self.parser.add_option("-e", type="duration", default="6m")

        self.parser.set_defaults(n="42")

        self.expected.update({'d': 300, 'e': 360, 'n': 42})

        self.assertEqual(self.parser.get_default_values(), self.expected)

        self.parser.set_process_default_values(False)

        self.expected.update({'d': 300, 'e': "6m", 'n': "42"})

        self.assertEqual(self.parser.get_default_values(), self.expected)

class TestProgName(BaseTest):

    """

    Test that %prog expands to the right thing in usage, version,

    and help strings.

    """

    def assertUsage(self, parser, expected_usage):

        self.assertEqual(parser.get_usage(), expected_usage)