/brz/remove-bazaar

# Copyright (C) 2011, 2016 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

import re

import sys

import textwrap

from io import StringIO

from .. import (

    commands,

    export_pot,

    option,

    registry,

    tests,

    )

class TestEscape(tests.TestCase):

    def test_simple_escape(self):

        self.assertEqual(

            export_pot._escape('foobar'),

            'foobar')

        s = '''foo\nbar\r\tbaz\\"spam"'''

        e = '''foo\\nbar\\r\\tbaz\\\\\\"spam\\"'''

        self.assertEqual(export_pot._escape(s), e)

    def test_complex_escape(self):

        s = '''\\r \\\n'''

        e = '''\\\\r \\\\\\n'''

        self.assertEqual(export_pot._escape(s), e)

class TestNormalize(tests.TestCase):

    def test_single_line(self):

        s = 'foobar'

        e = '"foobar"'

        self.assertEqual(export_pot._normalize(s), e)

        s = 'foo"bar'

        e = '"foo\\"bar"'

        self.assertEqual(export_pot._normalize(s), e)

    def test_multi_lines(self):

        s = 'foo\nbar\n'

        e = '""\n"foo\\n"\n"bar\\n"'

        self.assertEqual(export_pot._normalize(s), e)

        s = '\nfoo\nbar\n'

        e = ('""\n'

             '"\\n"\n'

             '"foo\\n"\n'

             '"bar\\n"')

        self.assertEqual(export_pot._normalize(s), e)

class TestParseSource(tests.TestCase):

    """Check mappings to line numbers generated from python source"""

    def test_classes(self):

        src = '''

class Ancient:

    """Old style class"""

class Modern(object):

    """New style class"""

'''

        cls_lines, _ = export_pot._parse_source(src)

        self.assertEqual(cls_lines,

                         {"Ancient": 2, "Modern": 5})

    def test_classes_nested(self):

        src = '''

class Matroska(object):

    class Smaller(object):

        class Smallest(object):

            pass

'''

        cls_lines, _ = export_pot._parse_source(src)

        self.assertEqual(cls_lines,

                         {"Matroska": 2, "Smaller": 3, "Smallest": 4})

    def test_strings_docstrings(self):

        src = '''\

"""Module"""

def function():

    """Function"""

class Class(object):

    """Class"""

    def method(self):

        """Method"""

'''

        _, str_lines = export_pot._parse_source(src)

        self.assertEqual(str_lines,

                         {"Module": 1, "Function": 4, "Class": 7, "Method": 10})

    def test_strings_literals(self):

        src = '''\

s = "One"

t = (2, "Two")

f = dict(key="Three")

'''

        _, str_lines = export_pot._parse_source(src)

        self.assertEqual(str_lines,

                         {"One": 1, "Two": 2, "Three": 3})

    def test_strings_multiline(self):

        src = '''\

"""Start

End

"""

t = (

    "A"

    "B"

    "C"

    )

'''

        _, str_lines = export_pot._parse_source(src)

        self.assertEqual(str_lines,

                         {"Start\n\nEnd\n": 1, "ABC": 6})

    def test_strings_multiline_escapes(self):

        src = '''\

s = "Escaped\\n"

r = r"Raw\\n"

t = (

    "A\\n\\n"

    "B\\n\\n"

    "C\\n\\n"

    )

'''

        _, str_lines = export_pot._parse_source(src)

        if sys.version_info < (3, 8):

            self.expectFailure("Escaped newlines confuses the multiline handling",

                               self.assertNotEqual, str_lines,

                               {"Escaped\n": 0, "Raw\\n": 2, "A\n\nB\n\nC\n\n": -2})

        else:

            self.assertEqual(

                str_lines, {"Escaped\n": 1, "Raw\\n": 2, "A\n\nB\n\nC\n\n": 4})

class TestModuleContext(tests.TestCase):

    """Checks for source context tracking objects"""

    def check_context(self, context, path, lineno):

        self.assertEqual((context.path, context.lineno), (path, lineno))

    def test___init__(self):

        context = export_pot._ModuleContext("one.py")

        self.check_context(context, "one.py", 1)

        context = export_pot._ModuleContext("two.py", 5)

        self.check_context(context, "two.py", 5)

    def test_from_class(self):

        """New context returned with lineno updated from class"""

        path = "cls.py"

        class A(object):

            pass

        class B(object):

            pass

        cls_lines = {"A": 5, "B": 7}

        context = export_pot._ModuleContext(path, _source_info=(cls_lines, {}))

        contextA = context.from_class(A)

        self.check_context(contextA, path, 5)

        contextB1 = context.from_class(B)

        self.check_context(contextB1, path, 7)

        contextB2 = contextA.from_class(B)

        self.check_context(contextB2, path, 7)

        self.check_context(context, path, 1)

        self.assertEqual("", self.get_log())

    def test_from_class_missing(self):

        """When class has no lineno the old context details are returned"""

        path = "cls_missing.py"

        class A(object):

            pass

        class M(object):

            pass

        context = export_pot._ModuleContext(path, 3, ({"A": 15}, {}))

        contextA = context.from_class(A)

        contextM1 = context.from_class(M)

        self.check_context(contextM1, path, 3)

        contextM2 = contextA.from_class(M)

        self.check_context(contextM2, path, 15)

        self.assertContainsRe(self.get_log(), "Definition of <.*M'> not found")

    def test_from_string(self):

        """New context returned with lineno updated from string"""

        path = "str.py"

        str_lines = {"one": 14, "two": 42}

        context = export_pot._ModuleContext(path, _source_info=({}, str_lines))

        context1 = context.from_string("one")

        self.check_context(context1, path, 14)

        context2A = context.from_string("two")

        self.check_context(context2A, path, 42)

        context2B = context1.from_string("two")

        self.check_context(context2B, path, 42)

        self.check_context(context, path, 1)

        self.assertEqual("", self.get_log())

    def test_from_string_missing(self):

        """When string has no lineno the old context details are returned"""

        path = "str_missing.py"

        context = export_pot._ModuleContext(path, 4, ({}, {"line\n": 21}))

        context1 = context.from_string("line\n")

        context2A = context.from_string("not there")

        self.check_context(context2A, path, 4)

        context2B = context1.from_string("not there")

        self.check_context(context2B, path, 21)

        self.assertContainsRe(self.get_log(), "String b?'not there' not found")

class TestWriteOption(tests.TestCase):

    """Tests for writing texts extracted from options in pot format"""

    def pot_from_option(self, opt, context=None, note="test"):

        sio = StringIO()

        exporter = export_pot._PotExporter(sio)

        if context is None:

            context = export_pot._ModuleContext("nowhere", 0)

        export_pot._write_option(exporter, context, opt, note)

        return sio.getvalue()

    def test_option_without_help(self):

        opt = option.Option("helpless")

        self.assertEqual("", self.pot_from_option(opt))

    def test_option_with_help(self):

        opt = option.Option("helpful", help="Info.")

        self.assertContainsString(self.pot_from_option(opt), "\n"

                                  "# help of 'helpful' test\n"

                                  "msgid \"Info.\"\n")

    def test_option_hidden(self):

        opt = option.Option("hidden", help="Unseen.", hidden=True)

        self.assertEqual("", self.pot_from_option(opt))

    def test_option_context_missing(self):

        context = export_pot._ModuleContext("remote.py", 3)

        opt = option.Option("metaphor", help="Not a literal in the source.")

        self.assertContainsString(self.pot_from_option(opt, context),

                                  "#: remote.py:3\n"

                                  "# help of 'metaphor' test\n")

    def test_option_context_string(self):

        s = "Literally."

        context = export_pot._ModuleContext("local.py", 3, ({}, {s: 17}))

        opt = option.Option("example", help=s)

        self.assertContainsString(self.pot_from_option(opt, context),

                                  "#: local.py:17\n"

                                  "# help of 'example' test\n")

    def test_registry_option_title(self):

        opt = option.RegistryOption.from_kwargs("group", help="Pick one.",

                                                title="Choose!")

        pot = self.pot_from_option(opt)

        self.assertContainsString(pot, "\n"

                                  "# title of 'group' test\n"

                                  "msgid \"Choose!\"\n")

        self.assertContainsString(pot, "\n"

                                  "# help of 'group' test\n"

                                  "msgid \"Pick one.\"\n")

    def test_registry_option_title_context_missing(self):

        context = export_pot._ModuleContext("theory.py", 3)

        opt = option.RegistryOption.from_kwargs("abstract", title="Unfounded!")

        self.assertContainsString(self.pot_from_option(opt, context),

                                  "#: theory.py:3\n"

                                  "# title of 'abstract' test\n")

    def test_registry_option_title_context_string(self):

        s = "Grounded!"

        context = export_pot._ModuleContext("practice.py", 3, ({}, {s: 144}))

        opt = option.RegistryOption.from_kwargs("concrete", title=s)

        self.assertContainsString(self.pot_from_option(opt, context),

                                  "#: practice.py:144\n"

                                  "# title of 'concrete' test\n")

    def test_registry_option_value_switches(self):

        opt = option.RegistryOption.from_kwargs("switch", help="Flip one.",

                                                value_switches=True, enum_switch=False,

                                                red="Big.", green="Small.")

        pot = self.pot_from_option(opt)

        self.assertContainsString(pot, "\n"

                                  "# help of 'switch' test\n"

                                  "msgid \"Flip one.\"\n")

        self.assertContainsString(pot, "\n"

                                  "# help of 'switch=red' test\n"

                                  "msgid \"Big.\"\n")

        self.assertContainsString(pot, "\n"

                                  "# help of 'switch=green' test\n"

                                  "msgid \"Small.\"\n")

    def test_registry_option_value_switches_hidden(self):

        reg = registry.Registry()

        class Hider(object):

            hidden = True

        reg.register("new", 1, "Current.")

        reg.register("old", 0, "Legacy.", info=Hider())

        opt = option.RegistryOption("protocol", "Talking.", reg,

                                    value_switches=True, enum_switch=False)

        pot = self.pot_from_option(opt)

        self.assertContainsString(pot, "\n"

                                  "# help of 'protocol' test\n"

                                  "msgid \"Talking.\"\n")

        self.assertContainsString(pot, "\n"

                                  "# help of 'protocol=new' test\n"

                                  "msgid \"Current.\"\n")

        self.assertNotContainsString(pot, "'protocol=old'")

class TestPotExporter(tests.TestCase):

    """Test for logic specific to the _PotExporter class"""

    # This test duplicates test_duplicates below

    def test_duplicates(self):

        exporter = export_pot._PotExporter(StringIO())

        context = export_pot._ModuleContext("mod.py", 1)

        exporter.poentry_in_context(context, "Common line.")

        context.lineno = 3

        exporter.poentry_in_context(context, "Common line.")

        self.assertEqual(1, exporter.outf.getvalue().count("Common line."))

    def test_duplicates_included(self):

        exporter = export_pot._PotExporter(StringIO(), True)

        context = export_pot._ModuleContext("mod.py", 1)

        exporter.poentry_in_context(context, "Common line.")

        context.lineno = 3

        exporter.poentry_in_context(context, "Common line.")

        self.assertEqual(2, exporter.outf.getvalue().count("Common line."))

class PoEntryTestCase(tests.TestCase):

    def setUp(self):

        super(PoEntryTestCase, self).setUp()

        self.exporter = export_pot._PotExporter(StringIO())

    def check_output(self, expected):

        self.assertEqual(

            self.exporter.outf.getvalue(),

            textwrap.dedent(expected)

            )

class TestPoEntry(PoEntryTestCase):

    def test_simple(self):

        self.exporter.poentry('dummy', 1, "spam")

        self.exporter.poentry('dummy', 2, "ham", 'EGG')

        self.check_output('''\

                #: dummy:1

                msgid "spam"

                msgstr ""

                #: dummy:2

                # EGG

                msgid "ham"

                msgstr ""

                ''')

    def test_duplicate(self):

        self.exporter.poentry('dummy', 1, "spam")

        # This should be ignored.

        self.exporter.poentry('dummy', 2, "spam", 'EGG')

        self.check_output('''\

                #: dummy:1

                msgid "spam"

                msgstr ""\n

                ''')

class TestPoentryPerPergraph(PoEntryTestCase):

    def test_single(self):

        self.exporter.poentry_per_paragraph(

            'dummy',

            10,

            '''foo\nbar\nbaz\n'''

            )

        self.check_output('''\

                #: dummy:10

                msgid ""

                "foo\\n"

                "bar\\n"

                "baz\\n"

                msgstr ""\n

                ''')

    def test_multi(self):

        self.exporter.poentry_per_paragraph(

            'dummy',

            10,

            '''spam\nham\negg\n\nSPAM\nHAM\nEGG\n'''

            )

        self.check_output('''\

                #: dummy:10

                msgid ""

                "spam\\n"

                "ham\\n"

                "egg"

                msgstr ""

                #: dummy:14

                msgid ""

                "SPAM\\n"

                "HAM\\n"

                "EGG\\n"

                msgstr ""\n

                ''')

class TestExportCommandHelp(PoEntryTestCase):

    def test_command_help(self):

        class cmd_Demo(commands.Command):

            __doc__ = """A sample command.

            :Usage:

                bzr demo

            :Examples:

                Example 1::

                    cmd arg1

            Blah Blah Blah

            """

        export_pot._write_command_help(self.exporter, cmd_Demo())

        result = self.exporter.outf.getvalue()

        # We don't care about filename and lineno here.

        result = re.sub(r'(?m)^#: [^\n]+\n', '', result)

        self.assertEqualDiff(

            'msgid "A sample command."\n'

            'msgstr ""\n'

            '\n'                # :Usage: should not be translated.

            'msgid ""\n'

            '":Examples:\\n"\n'

            '"    Example 1::"\n'

            'msgstr ""\n'

            '\n'

            'msgid "        cmd arg1"\n'

            'msgstr ""\n'

            '\n'

            'msgid "Blah Blah Blah"\n'

            'msgstr ""\n'

            '\n',

            result

            )