/brz/remove-bazaar

# Copyright (C) 2005-2012, 2016 Canonical Ltd, 2017 Breezy developers

#

# 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

"""Tests for plugins"""

import imp

import importlib

import logging

import os

import sys

import breezy

from .. import (

    errors,

    osutils,

    plugin,

    tests,

    trace,

    )

from ..sixish import (

    PY3,

    StringIO,

    viewkeys,

    )

# TODO: Write a test for plugin decoration of commands.

invalidate_caches = getattr(importlib, "invalidate_caches", lambda: None)

class BaseTestPlugins(tests.TestCaseInTempDir):

    """TestCase that isolates plugin imports and cleans up on completion."""

    def setUp(self):

        super(BaseTestPlugins, self).setUp()

        self.module_name = "breezy.testingplugins"

        self.module_prefix = self.module_name + "."

        self.module = imp.new_module(self.module_name)

        self.overrideAttr(plugin, "_MODULE_PREFIX", self.module_prefix)

        self.overrideAttr(breezy, "testingplugins", self.module)

        sys.modules[self.module_name] = self.module

        self.addCleanup(self._unregister_all)

        self.addCleanup(self._unregister_finder)

        invalidate_caches()

    def reset(self):

        """Remove all global testing state and clean up module."""

        # GZ 2017-06-02: Ideally don't do this, write new test or generate

        # bytecode by other mechanism.

        self.log("resetting plugin testing context")

        self._unregister_all()

        self._unregister_finder()

        sys.modules[self.module_name] = self.module

        for name in list(self.module.__dict__):

            if name[:2] != '__':

                delattr(self.module, name)

        invalidate_caches()

        self.plugins = None

    def update_module_paths(self, paths):

        paths = plugin.extend_path(paths, self.module_name)

        self.module.__path__ = paths

        self.log("using %r", paths)

        return paths

    def load_with_paths(self, paths):

        self.log("loading plugins!")

        plugin.load_plugins(self.update_module_paths(paths), state=self)

    def create_plugin(self, name, source=None, dir='.', file_name=None):

        if source is None:

            source = '''\

"""This is the doc for %s"""

''' % (name)

        if file_name is None:

            file_name = name + '.py'

        # 'source' must not fail to load

        path = osutils.pathjoin(dir, file_name)

        with open(path, 'w') as f:

            f.write(source + '\n')

    def create_plugin_package(self, name, dir=None, source=None):

        if dir is None:

            dir = name

        if source is None:

            source = '''\

"""This is the doc for %s"""

dir_source = '%s'

''' % (name, dir)

        os.makedirs(dir)

        self.create_plugin(name, source, dir,

                           file_name='__init__.py')

    def promote_cache(self, directory):

        """Move bytecode files out of __pycache__ in given directory."""

        cache_dir = os.path.join(directory, '__pycache__')

        if os.path.isdir(cache_dir):

            for name in os.listdir(cache_dir):

                magicless_name = '.'.join(name.split('.')[0::name.count('.')])

                rel = osutils.relpath(self.test_dir, cache_dir)

                self.log("moving %s in %s to %s", name, rel, magicless_name)

                os.rename(os.path.join(cache_dir, name),

                    os.path.join(directory, magicless_name))

    def _unregister_finder(self):

        """Removes any test copies of _PluginsAtFinder from sys.meta_path."""

        idx = len(sys.meta_path)

        while idx:

            idx -= 1

            finder = sys.meta_path[idx]

            if getattr(finder, "prefix", "") == self.module_prefix:

                self.log("removed %r from sys.meta_path", finder)

                sys.meta_path.pop(idx)

    def _unregister_all(self):

        """Remove all plugins in the test namespace from sys.modules."""

        for name in list(sys.modules):

            if name.startswith(self.module_prefix) or name == self.module_name:

                self.log("removed %s from sys.modules", name)

                del sys.modules[name]

    def assertPluginModules(self, plugin_dict):

        self.assertEqual(

            dict((k[len(self.module_prefix):], sys.modules[k])

                for k in sys.modules if k.startswith(self.module_prefix)),

            plugin_dict)

    def assertPluginUnknown(self, name):

        self.assertTrue(getattr(self.module, name, None) is None)

        self.assertFalse(self.module_prefix + name in sys.modules)

    def assertPluginKnown(self, name):

        self.assertTrue(getattr(self.module, name, None) is not None)

        self.assertTrue(self.module_prefix + name in sys.modules)

class TestLoadingPlugins(BaseTestPlugins):

    activeattributes = {}

    def test_plugins_with_the_same_name_are_not_loaded(self):

        # This test tests that having two plugins in different directories does

        # not result in both being loaded when they have the same name.  get a

        # file name we can use which is also a valid attribute for accessing in

        # activeattributes. - we cannot give import parameters.

        tempattribute = "0"

        self.assertFalse(tempattribute in self.activeattributes)

        # set a place for the plugins to record their loading, and at the same

        # time validate that the location the plugins should record to is

        # valid and correct.

        self.__class__.activeattributes [tempattribute] = []

        self.assertTrue(tempattribute in self.activeattributes)

        # create two plugin directories

        os.mkdir('first')

        os.mkdir('second')

        # write a plugin that will record when its loaded in the

        # tempattribute list.

        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"

                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")

        with open(os.path.join('first', 'plugin.py'), 'w') as outfile:

            outfile.write(template % (tempattribute, 'first'))

            outfile.write('\n')

        with open(os.path.join('second', 'plugin.py'), 'w') as outfile:

            outfile.write(template % (tempattribute, 'second'))

            outfile.write('\n')

        try:

            self.load_with_paths(['first', 'second'])

            self.assertEqual(['first'], self.activeattributes[tempattribute])

        finally:

            del self.activeattributes[tempattribute]

    def test_plugins_from_different_dirs_can_demand_load(self):

        self.assertFalse('breezy.plugins.pluginone' in sys.modules)

        self.assertFalse('breezy.plugins.plugintwo' in sys.modules)

        # This test tests that having two plugins in different

        # directories with different names allows them both to be loaded, when

        # we do a direct import statement.

        # Determine a file name we can use which is also a valid attribute

        # for accessing in activeattributes. - we cannot give import parameters.

        tempattribute = "different-dirs"

        self.assertFalse(tempattribute in self.activeattributes)

        # set a place for the plugins to record their loading, and at the same

        # time validate that the location the plugins should record to is

        # valid and correct.

        breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \

            [tempattribute] = []

        self.assertTrue(tempattribute in self.activeattributes)

        # create two plugin directories

        os.mkdir('first')

        os.mkdir('second')

        # write plugins that will record when they are loaded in the

        # tempattribute list.

        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"

                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")

        with open(os.path.join('first', 'pluginone.py'), 'w') as outfile:

            outfile.write(template % (tempattribute, 'first'))

            outfile.write('\n')

        with open(os.path.join('second', 'plugintwo.py'), 'w') as outfile:

            outfile.write(template % (tempattribute, 'second'))

            outfile.write('\n')

        try:

            self.assertPluginUnknown('pluginone')

            self.assertPluginUnknown('plugintwo')

            self.update_module_paths(['first', 'second'])

            exec("import %spluginone" % self.module_prefix)

            self.assertEqual(['first'], self.activeattributes[tempattribute])

            exec("import %splugintwo" % self.module_prefix)

            self.assertEqual(['first', 'second'],

                self.activeattributes[tempattribute])

        finally:

            del self.activeattributes[tempattribute]

    def test_plugins_can_load_from_directory_with_trailing_slash(self):

        # This test tests that a plugin can load from a directory when the

        # directory in the path has a trailing slash.

        # check the plugin is not loaded already

        self.assertPluginUnknown('ts_plugin')

        tempattribute = "trailing-slash"

        self.assertFalse(tempattribute in self.activeattributes)

        # set a place for the plugin to record its loading, and at the same

        # time validate that the location the plugin should record to is

        # valid and correct.

        breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \

            [tempattribute] = []

        self.assertTrue(tempattribute in self.activeattributes)

        # create a directory for the plugin

        os.mkdir('plugin_test')

        # write a plugin that will record when its loaded in the

        # tempattribute list.

        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"

                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")

        with open(os.path.join('plugin_test', 'ts_plugin.py'), 'w') as outfile:

            outfile.write(template % (tempattribute, 'plugin'))

            outfile.write('\n')

        try:

            self.load_with_paths(['plugin_test'+os.sep])

            self.assertEqual(['plugin'], self.activeattributes[tempattribute])

            self.assertPluginKnown('ts_plugin')

        finally:

            del self.activeattributes[tempattribute]

    def load_and_capture(self, name):

        """Load plugins from '.' capturing the output.

        :param name: The name of the plugin.

        :return: A string with the log from the plugin loading call.

        """

        # Capture output

        stream = StringIO()

        try:

            handler = logging.StreamHandler(stream)

            log = logging.getLogger('brz')

            log.addHandler(handler)

            try:

                self.load_with_paths(['.'])

            finally:

                # Stop capturing output

                handler.flush()

                handler.close()

                log.removeHandler(handler)

            return stream.getvalue()

        finally:

            stream.close()

    def test_plugin_with_bad_api_version_reports(self):

        """Try loading a plugin that requests an unsupported api.

        Observe that it records the problem but doesn't complain on stderr.

        See https://bugs.launchpad.net/bzr/+bug/704195

        """

        name = 'wants100.py'

        with open(name, 'w') as f:

            f.write("import breezy\n"

                "from breezy.errors import IncompatibleVersion\n"

                "raise IncompatibleVersion(breezy, [(1, 0, 0)], (0, 0, 5))\n")

        log = self.load_and_capture(name)

        self.assertNotContainsRe(log,

            r"It supports breezy version")

        self.assertEqual({'wants100'}, viewkeys(self.plugin_warnings))

        self.assertContainsRe(

            self.plugin_warnings['wants100'][0],

            r"It supports breezy version")

    def test_plugin_with_bad_name_does_not_load(self):

        # The file name here invalid for a python module.

        name = 'brz-bad plugin-name..py'

        open(name, 'w').close()

        log = self.load_and_capture(name)

        self.assertContainsRe(log,

            r"Unable to load 'brz-bad plugin-name\.' in '\.' as a plugin "

            "because the file path isn't a valid module name; try renaming "

            "it to 'bad_plugin_name_'\.")

class TestPlugins(BaseTestPlugins):

    def setup_plugin(self, source=""):

        # This test tests a new plugin appears in breezy.plugin.plugins().

        # check the plugin is not loaded already

        self.assertPluginUnknown('plugin')

        # write a plugin that _cannot_ fail to load.

        with open('plugin.py', 'w') as f: f.write(source + '\n')

        self.load_with_paths(['.'])

    def test_plugin_loaded(self):

        self.assertPluginUnknown('plugin')

        self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))

        self.setup_plugin()

        p = breezy.plugin.get_loaded_plugin('plugin')

        self.assertIsInstance(p, breezy.plugin.PlugIn)

        self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])

    def test_plugin_appears_in_plugins(self):

        self.setup_plugin()

        self.assertPluginKnown('plugin')

        p = self.plugins['plugin']

        self.assertIsInstance(p, breezy.plugin.PlugIn)

        self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])

    def test_trivial_plugin_get_path(self):

        self.setup_plugin()

        p = self.plugins['plugin']

        plugin_path = self.test_dir + '/plugin.py'

        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))

    def test_plugin_get_path_py_not_pyc(self):

        # first import creates plugin.pyc

        self.setup_plugin()

        self.promote_cache(self.test_dir)

        self.reset()

        self.load_with_paths(['.']) # import plugin.pyc

        p = plugin.plugins()['plugin']

        plugin_path = self.test_dir + '/plugin.py'

        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))

    def test_plugin_get_path_pyc_only(self):

        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)

        self.setup_plugin()

        os.unlink(self.test_dir + '/plugin.py')

        self.promote_cache(self.test_dir)

        self.reset()

        self.load_with_paths(['.']) # import plugin.pyc (or .pyo)

        p = plugin.plugins()['plugin']

        plugin_path = self.test_dir + '/plugin' + plugin.COMPILED_EXT

        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))

    def test_no_test_suite_gives_None_for_test_suite(self):

        self.setup_plugin()

        p = plugin.plugins()['plugin']

        self.assertEqual(None, p.test_suite())

    def test_test_suite_gives_test_suite_result(self):

        source = """def test_suite(): return 'foo'"""

        self.setup_plugin(source)

        p = plugin.plugins()['plugin']

        self.assertEqual('foo', p.test_suite())

    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):

        self.setup_plugin()

        loader = tests.TestUtil.TestLoader()

        p = plugin.plugins()['plugin']

        self.assertEqual(None, p.load_plugin_tests(loader))

    def test_load_plugin_tests_gives_load_plugin_tests_result(self):

        source = """

def load_tests(loader, standard_tests, pattern):

    return 'foo'"""

        self.setup_plugin(source)

        loader = tests.TestUtil.TestLoader()

        p = plugin.plugins()['plugin']

        self.assertEqual('foo', p.load_plugin_tests(loader))

    def check_version_info(self, expected, source='', name='plugin'):

        self.setup_plugin(source)

        self.assertEqual(expected, plugin.plugins()[name].version_info())

    def test_no_version_info(self):

        self.check_version_info(None)

    def test_with_version_info(self):

        self.check_version_info((1, 2, 3, 'dev', 4),

                                "version_info = (1, 2, 3, 'dev', 4)")

    def test_short_version_info_gets_padded(self):

        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.

        # so we adapt it

        self.check_version_info((1, 2, 3, 'final', 0),

                                "version_info = (1, 2, 3)")

    def check_version(self, expected, source=None, name='plugin'):

        self.setup_plugin(source)

        self.assertEqual(expected, plugins[name].__version__)

    def test_no_version_info___version__(self):

        self.setup_plugin()

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("unknown", plugin.__version__)

    def test_str__version__with_version_info(self):

        self.setup_plugin("version_info = '1.2.3'")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3", plugin.__version__)

    def test_noniterable__version__with_version_info(self):

        self.setup_plugin("version_info = (1)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1", plugin.__version__)

    def test_1__version__with_version_info(self):

        self.setup_plugin("version_info = (1,)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1", plugin.__version__)

    def test_1_2__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2", plugin.__version__)

    def test_1_2_3__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3", plugin.__version__)

    def test_candidate__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3rc1", plugin.__version__)

    def test_dev__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3dev", plugin.__version__)

    def test_dev_fallback__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3dev4", plugin.__version__)

    def test_final__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3", plugin.__version__)

    def test_final_fallback__version__with_version_info(self):

        self.setup_plugin("version_info = (1, 2, 3, 'final', 2)")

        plugin = breezy.plugin.plugins()['plugin']

        self.assertEqual("1.2.3.2", plugin.__version__)

# GZ 2017-06-02: Move this suite to blackbox, as it's what it actually is.

class TestPluginHelp(BaseTestPlugins):

    def split_help_commands(self):

        help = {}

        current = None

        out, err = self.run_bzr('--no-plugins help commands')

        for line in out.splitlines():

            if not line.startswith(' '):

                current = line.split()[0]

            help[current] = help.get(current, '') + line

        return help

    def test_plugin_help_builtins_unaffected(self):

        # Check we don't get false positives

        help_commands = self.split_help_commands()

        for cmd_name in breezy.commands.builtin_command_names():

            if cmd_name in breezy.commands.plugin_command_names():

                continue

            try:

                help = breezy.commands.get_cmd_object(cmd_name).get_help_text()

            except NotImplementedError:

                # some commands have no help

                pass

            else:

                self.assertNotContainsRe(help, 'plugin "[^"]*"')

            if cmd_name in help_commands:

                # some commands are hidden

                help = help_commands[cmd_name]

                self.assertNotContainsRe(help, 'plugin "[^"]*"')

    def test_plugin_help_shows_plugin(self):

        # Create a test plugin

        os.mkdir('plugin_test')

        source = (

            "from breezy import commands\n"

            "class cmd_myplug(commands.Command):\n"

            "    __doc__ = '''Just a simple test plugin.'''\n"

            "    aliases = ['mplg']\n"

            "    def run(self):\n"

            "        print ('Hello from my plugin')\n"

        )

        self.create_plugin('myplug', source, 'plugin_test')

        # Check its help

        self.load_with_paths(['plugin_test'])

        myplug = self.plugins['myplug'].module

        breezy.commands.register_command(myplug.cmd_myplug)

        self.addCleanup(breezy.commands.plugin_cmds.remove, 'myplug')

        help = self.run_bzr('help myplug')[0]

        self.assertContainsRe(help, 'plugin "myplug"')

        help = self.split_help_commands()['myplug']

        self.assertContainsRe(help, '\[myplug\]')

class TestHelpIndex(tests.TestCase):

    """Tests for the PluginsHelpIndex class."""

    def test_default_constructable(self):

        index = plugin.PluginsHelpIndex()

    def test_get_topics_None(self):

        """Searching for None returns an empty list."""

        index = plugin.PluginsHelpIndex()

        self.assertEqual([], index.get_topics(None))

    def test_get_topics_for_plugin(self):

        """Searching for plugin name gets its docstring."""

        index = plugin.PluginsHelpIndex()

        # make a new plugin here for this test, even if we're run with

        # --no-plugins

        self.assertFalse('breezy.plugins.demo_module' in sys.modules)

        demo_module = FakeModule('', 'breezy.plugins.demo_module')

        sys.modules['breezy.plugins.demo_module'] = demo_module

        try:

            topics = index.get_topics('demo_module')

            self.assertEqual(1, len(topics))

            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)

            self.assertEqual(demo_module, topics[0].module)

        finally:

            del sys.modules['breezy.plugins.demo_module']

    def test_get_topics_no_topic(self):

        """Searching for something that is not a plugin returns []."""

        # test this by using a name that cannot be a plugin - its not

        # a valid python identifier.

        index = plugin.PluginsHelpIndex()

        self.assertEqual([], index.get_topics('nothing by this name'))

    def test_prefix(self):

        """PluginsHelpIndex has a prefix of 'plugins/'."""

        index = plugin.PluginsHelpIndex()

        self.assertEqual('plugins/', index.prefix)

    def test_get_plugin_topic_with_prefix(self):

        """Searching for plugins/demo_module returns help."""

        index = plugin.PluginsHelpIndex()

        self.assertFalse('breezy.plugins.demo_module' in sys.modules)

        demo_module = FakeModule('', 'breezy.plugins.demo_module')

        sys.modules['breezy.plugins.demo_module'] = demo_module

        try:

            topics = index.get_topics('plugins/demo_module')

            self.assertEqual(1, len(topics))

            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)

            self.assertEqual(demo_module, topics[0].module)

        finally: