Attachment 1468877 Details for Bug 1606649 – build.log

build.log

build.log (text/plain), 32.00 KB, created by Mohan Boddu on 2018-07-20 21:02:03 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mohan Boddu

Created: 2018-07-20 21:02:03 UTC

Size: 32.00 KB

patch

obsolete

>xec_vint_with_verbose_flag(self):
>        valid_file = str(Path('test', 'fixture', 'cli', 'valid1.vim'))
>        cmd = ['vint', '--verbose', valid_file]
>    
>        got_output = subprocess.check_output(cmd,
>                                             universal_newlines=True,
>>                                            stderr=subprocess.STDOUT)
>test/acceptance/test_cli.py:127: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>/usr/lib64/python3.7/subprocess.py:376: in check_output
>    **kwargs).stdout
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>input = None, capture_output = False, timeout = None, check = True
>popenargs = (['vint', '--verbose', 'test/fixture/cli/valid1.vim'],)
>kwargs = {'stderr': -2, 'stdout': -1, 'universal_newlines': True}
>process = <subprocess.Popen object at 0xffff7a59a320>
>stdout = 'Traceback (most recent call last):\n  File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 570, in...rs)\npkg_resources.DistributionNotFound: The \'PyYAML~=3.11\' distribution was not found and is required by vim-vint\n'
>stderr = None, retcode = 1
>    def run(*popenargs,
>            input=None, capture_output=False, timeout=None, check=False, **kwargs):
>        """Run command with arguments and return a CompletedProcess instance.
>    
>        The returned instance will have attributes args, returncode, stdout and
>        stderr. By default, stdout and stderr are not captured, and those attributes
>        will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them.
>    
>        If check is True and the exit code was non-zero, it raises a
>        CalledProcessError. The CalledProcessError object will have the return code
>        in the returncode attribute, and output & stderr attributes if those streams
>        were captured.
>    
>        If timeout is given, and the process takes too long, a TimeoutExpired
>        exception will be raised.
>    
>        There is an optional argument "input", allowing you to
>        pass bytes or a string to the subprocess's stdin.  If you use this argument
>        you may not also use the Popen constructor's "stdin" argument, as
>        it will be used internally.
>    
>        By default, all communication is in bytes, and therefore any "input" should
>        be bytes, and the stdout and stderr will be bytes. If in text mode, any
>        "input" should be a string, and stdout and stderr will be strings decoded
>        according to locale encoding, or by "encoding" if set. Text mode is
>        triggered by setting any of text, encoding, errors or universal_newlines.
>    
>        The other arguments are the same as for the Popen constructor.
>        """
>        if input is not None:
>            if 'stdin' in kwargs:
>                raise ValueError('stdin and input arguments may not both be used.')
>            kwargs['stdin'] = PIPE
>    
>        if capture_output:
>            if ('stdout' in kwargs) or ('stderr' in kwargs):
>                raise ValueError('stdout and stderr arguments may not be used '
>                                 'with capture_output.')
>            kwargs['stdout'] = PIPE
>            kwargs['stderr'] = PIPE
>    
>        with Popen(*popenargs, **kwargs) as process:
>            try:
>                stdout, stderr = process.communicate(input, timeout=timeout)
>            except TimeoutExpired:
>                process.kill()
>                stdout, stderr = process.communicate()
>                raise TimeoutExpired(process.args, timeout, output=stdout,
>                                     stderr=stderr)
>            except:  # Including KeyboardInterrupt, communicate handled that.
>                process.kill()
>                # We don't call process.wait() as .__exit__ does that for us.
>                raise
>            retcode = process.poll()
>            if check and retcode:
>                raise CalledProcessError(retcode, process.args,
>>                                        output=stdout, stderr=stderr)
>E               subprocess.CalledProcessError: Command '['vint', '--verbose', 'test/fixture/cli/valid1.vim']' returned non-zero exit status 1.
>/usr/lib64/python3.7/subprocess.py:468: CalledProcessError
>_________ TestVintDoNotDiedWhenLintingVital.test_survive_after_linting _________
>self = <test.acceptance.test_cli_vital.TestVintDoNotDiedWhenLintingVital testMethod=test_survive_after_linting>
>    def test_survive_after_linting(self):
>        vital_dir = str(Path('test', 'fixture', 'cli', 'vital.vim'))
>        cmd = ['vint', vital_dir]
>    
>>       self.assertVintStillAlive(cmd)
>test/acceptance/test_cli_vital.py:24: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/acceptance/test_cli_vital.py:17: in assertVintStillAlive
>    'vint was died when linting vital.vim: ' + got_output)
>E   AssertionError: True is not false : vint was died when linting vital.vim: Traceback (most recent call last):
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 570, in _build_master
>E       ws.require(__requires__)
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 888, in require
>E       needed = self.resolve(parse_requirements(requirements))
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 779, in resolve
>E       raise VersionConflict(dist, req).with_context(dependent_req)
>E   pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>E   
>E   During handling of the above exception, another exception occurred:
>E   
>E   Traceback (most recent call last):
>E     File "/builddir/build/BUILDROOT/vint-0.3.18-4.fc29.noarch/usr/bin/vint", line 6, in <module>
>E       from pkg_resources import load_entry_point
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 3095, in <module>
>E       @_call_aside
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 3079, in _call_aside
>E       f(*args, **kwargs)
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 3108, in _initialize_master_working_set
>E       working_set = WorkingSet._build_master()
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 572, in _build_master
>E       return cls._build_from_requirements(__requires__)
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 585, in _build_from_requirements
>E       dists = ws.resolve(reqs, Environment())
>E     File "/usr/lib/python3.7/site-packages/pkg_resources/__init__.py", line 774, in resolve
>E       raise DistributionNotFound(req, requirers)
>E   pkg_resources.DistributionNotFound: The 'PyYAML~=3.11' distribution was not found and is required by vim-vint
>____________ TestCLI.test_start_with_both_calid_invalid_file_paths _____________
>self = <test.unit.vint.linting.test_cli.TestCLI testMethod=test_start_with_both_calid_invalid_file_paths>
>    def test_start_with_both_calid_invalid_file_paths(self):
>        argv = ['bin/vint', 'test/fixture/cli/valid1.vim', 'test/fixture/cli/invalid1.vim']
>>       self.assertExitWithFailure(argv)
>test/unit/vint/linting/test_cli.py:56: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/unit/vint/linting/test_cli.py:29: in assertExitWithFailure
>    cli.start()
>vint/linting/cli.py:21: in start
>    env = self._build_env(sys.argv)
>vint/linting/cli.py:103: in _build_env
>    cmdargs = self._build_cmdargs(argv)
>vint/linting/cli.py:92: in _build_cmdargs
>    parser = self._build_argparser()
>vint/linting/cli.py:68: in _build_argparser
>    parser.add_argument('-v', '--version', action='version', version=self._get_version())
>vint/linting/cli.py:149: in _get_version
>    version = pkg_resources.require('vim-vint')[0].version
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:888: in require
>    needed = self.resolve(parse_requirements(requirements))
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>    def resolve(self, requirements, env=None, installer=None,
>                replace_conflicting=False, extras=None):
>        """List all distributions needed to (recursively) meet `requirements`
>    
>            `requirements` must be a sequence of ``Requirement`` objects.  `env`,
>            if supplied, should be an ``Environment`` instance.  If
>            not supplied, it defaults to all distributions available within any
>            entry or distribution in the working set.  `installer`, if supplied,
>            will be invoked with each requirement that cannot be met by an
>            already-installed distribution; it should return a ``Distribution`` or
>            ``None``.
>    
>            Unless `replace_conflicting=True`, raises a VersionConflict exception
>            if
>            any requirements are found on the path that have the correct name but
>            the wrong version.  Otherwise, if an `installer` is supplied it will be
>            invoked to obtain the correct version of the requirement and activate
>            it.
>    
>            `extras` is a list of the extras to be used with these requirements.
>            This is important because extra requirements may look like `my_req;
>            extra = "my_extra"`, which would otherwise be interpreted as a purely
>            optional requirement.  Instead, we want to be able to assert that these
>            requirements are truly required.
>            """
>    
>        # set up the stack
>        requirements = list(requirements)[::-1]
>        # set of processed requirements
>        processed = {}
>        # key -> dist
>        best = {}
>        to_activate = []
>    
>        req_extras = _ReqExtras()
>    
>        # Mapping of requirement to set of distributions that required it;
>        # useful for reporting info about conflicts.
>        required_by = collections.defaultdict(set)
>    
>        while requirements:
>            # process dependencies breadth-first
>            req = requirements.pop(0)
>            if req in processed:
>                # Ignore cyclic or redundant dependencies
>                continue
>    
>            if not req_extras.markers_pass(req, extras):
>                continue
>    
>            dist = best.get(req.key)
>            if dist is None:
>                # Find the best distribution and add it to the map
>                dist = self.by_key.get(req.key)
>                if dist is None or (dist not in req and replace_conflicting):
>                    ws = self
>                    if env is None:
>                        if dist is None:
>                            env = Environment(self.entries)
>                        else:
>                            # Use an empty environment and workingset to avoid
>                            # any further conflicts with the conflicting
>                            # distribution
>                            env = Environment([])
>                            ws = WorkingSet([])
>                    dist = best[req.key] = env.best_match(
>                        req, ws, installer,
>                        replace_conflicting=replace_conflicting
>                    )
>                    if dist is None:
>                        requirers = required_by.get(req, None)
>                        raise DistributionNotFound(req, requirers)
>                to_activate.append(dist)
>            if dist not in req:
>                # Oops, the "best" so far conflicts with a dependency
>                dependent_req = required_by[req]
>>               raise VersionConflict(dist, req).with_context(dependent_req)
>E               pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:779: ContextualVersionConflict
>__________________ TestCLI.test_start_with_invalid_file_path ___________________
>self = <test.unit.vint.linting.test_cli.TestCLI testMethod=test_start_with_invalid_file_path>
>    def test_start_with_invalid_file_path(self):
>        argv = ['bin/vint', 'test/fixture/cli/invalid1.vim']
>>       self.assertExitWithFailure(argv)
>test/unit/vint/linting/test_cli.py:51: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/unit/vint/linting/test_cli.py:29: in assertExitWithFailure
>    cli.start()
>vint/linting/cli.py:21: in start
>    env = self._build_env(sys.argv)
>vint/linting/cli.py:103: in _build_env
>    cmdargs = self._build_cmdargs(argv)
>vint/linting/cli.py:92: in _build_cmdargs
>    parser = self._build_argparser()
>vint/linting/cli.py:68: in _build_argparser
>    parser.add_argument('-v', '--version', action='version', version=self._get_version())
>vint/linting/cli.py:149: in _get_version
>    version = pkg_resources.require('vim-vint')[0].version
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:888: in require
>    needed = self.resolve(parse_requirements(requirements))
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>    def resolve(self, requirements, env=None, installer=None,
>                replace_conflicting=False, extras=None):
>        """List all distributions needed to (recursively) meet `requirements`
>    
>            `requirements` must be a sequence of ``Requirement`` objects.  `env`,
>            if supplied, should be an ``Environment`` instance.  If
>            not supplied, it defaults to all distributions available within any
>            entry or distribution in the working set.  `installer`, if supplied,
>            will be invoked with each requirement that cannot be met by an
>            already-installed distribution; it should return a ``Distribution`` or
>            ``None``.
>    
>            Unless `replace_conflicting=True`, raises a VersionConflict exception
>            if
>            any requirements are found on the path that have the correct name but
>            the wrong version.  Otherwise, if an `installer` is supplied it will be
>            invoked to obtain the correct version of the requirement and activate
>            it.
>    
>            `extras` is a list of the extras to be used with these requirements.
>            This is important because extra requirements may look like `my_req;
>            extra = "my_extra"`, which would otherwise be interpreted as a purely
>            optional requirement.  Instead, we want to be able to assert that these
>            requirements are truly required.
>            """
>    
>        # set up the stack
>        requirements = list(requirements)[::-1]
>        # set of processed requirements
>        processed = {}
>        # key -> dist
>        best = {}
>        to_activate = []
>    
>        req_extras = _ReqExtras()
>    
>        # Mapping of requirement to set of distributions that required it;
>        # useful for reporting info about conflicts.
>        required_by = collections.defaultdict(set)
>    
>        while requirements:
>            # process dependencies breadth-first
>            req = requirements.pop(0)
>            if req in processed:
>                # Ignore cyclic or redundant dependencies
>                continue
>    
>            if not req_extras.markers_pass(req, extras):
>                continue
>    
>            dist = best.get(req.key)
>            if dist is None:
>                # Find the best distribution and add it to the map
>                dist = self.by_key.get(req.key)
>                if dist is None or (dist not in req and replace_conflicting):
>                    ws = self
>                    if env is None:
>                        if dist is None:
>                            env = Environment(self.entries)
>                        else:
>                            # Use an empty environment and workingset to avoid
>                            # any further conflicts with the conflicting
>                            # distribution
>                            env = Environment([])
>                            ws = WorkingSet([])
>                    dist = best[req.key] = env.best_match(
>                        req, ws, installer,
>                        replace_conflicting=replace_conflicting
>                    )
>                    if dist is None:
>                        requirers = required_by.get(req, None)
>                        raise DistributionNotFound(req, requirers)
>                to_activate.append(dist)
>            if dist not in req:
>                # Oops, the "best" so far conflicts with a dependency
>                dependent_req = required_by[req]
>>               raise VersionConflict(dist, req).with_context(dependent_req)
>E               pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:779: ContextualVersionConflict
>________________________ TestCLI.test_start_with_no_arg ________________________
>self = <test.unit.vint.linting.test_cli.TestCLI testMethod=test_start_with_no_arg>
>    def test_start_with_no_arg(self):
>        argv = ['bin/vint']
>>       self.assertExitWithFailure(argv)
>test/unit/vint/linting/test_cli.py:36: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/unit/vint/linting/test_cli.py:29: in assertExitWithFailure
>    cli.start()
>vint/linting/cli.py:21: in start
>    env = self._build_env(sys.argv)
>vint/linting/cli.py:103: in _build_env
>    cmdargs = self._build_cmdargs(argv)
>vint/linting/cli.py:92: in _build_cmdargs
>    parser = self._build_argparser()
>vint/linting/cli.py:68: in _build_argparser
>    parser.add_argument('-v', '--version', action='version', version=self._get_version())
>vint/linting/cli.py:149: in _get_version
>    version = pkg_resources.require('vim-vint')[0].version
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:888: in require
>    needed = self.resolve(parse_requirements(requirements))
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>    def resolve(self, requirements, env=None, installer=None,
>                replace_conflicting=False, extras=None):
>        """List all distributions needed to (recursively) meet `requirements`
>    
>            `requirements` must be a sequence of ``Requirement`` objects.  `env`,
>            if supplied, should be an ``Environment`` instance.  If
>            not supplied, it defaults to all distributions available within any
>            entry or distribution in the working set.  `installer`, if supplied,
>            will be invoked with each requirement that cannot be met by an
>            already-installed distribution; it should return a ``Distribution`` or
>            ``None``.
>    
>            Unless `replace_conflicting=True`, raises a VersionConflict exception
>            if
>            any requirements are found on the path that have the correct name but
>            the wrong version.  Otherwise, if an `installer` is supplied it will be
>            invoked to obtain the correct version of the requirement and activate
>            it.
>    
>            `extras` is a list of the extras to be used with these requirements.
>            This is important because extra requirements may look like `my_req;
>            extra = "my_extra"`, which would otherwise be interpreted as a purely
>            optional requirement.  Instead, we want to be able to assert that these
>            requirements are truly required.
>            """
>    
>        # set up the stack
>        requirements = list(requirements)[::-1]
>        # set of processed requirements
>        processed = {}
>        # key -> dist
>        best = {}
>        to_activate = []
>    
>        req_extras = _ReqExtras()
>    
>        # Mapping of requirement to set of distributions that required it;
>        # useful for reporting info about conflicts.
>        required_by = collections.defaultdict(set)
>    
>        while requirements:
>            # process dependencies breadth-first
>            req = requirements.pop(0)
>            if req in processed:
>                # Ignore cyclic or redundant dependencies
>                continue
>    
>            if not req_extras.markers_pass(req, extras):
>                continue
>    
>            dist = best.get(req.key)
>            if dist is None:
>                # Find the best distribution and add it to the map
>                dist = self.by_key.get(req.key)
>                if dist is None or (dist not in req and replace_conflicting):
>                    ws = self
>                    if env is None:
>                        if dist is None:
>                            env = Environment(self.entries)
>                        else:
>                            # Use an empty environment and workingset to avoid
>                            # any further conflicts with the conflicting
>                            # distribution
>                            env = Environment([])
>                            ws = WorkingSet([])
>                    dist = best[req.key] = env.best_match(
>                        req, ws, installer,
>                        replace_conflicting=replace_conflicting
>                    )
>                    if dist is None:
>                        requirers = required_by.get(req, None)
>                        raise DistributionNotFound(req, requirers)
>                to_activate.append(dist)
>            if dist not in req:
>                # Oops, the "best" so far conflicts with a dependency
>                dependent_req = required_by[req]
>>               raise VersionConflict(dist, req).with_context(dependent_req)
>E               pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:779: ContextualVersionConflict
>_________________ TestCLI.test_start_with_unexistent_file_path _________________
>self = <test.unit.vint.linting.test_cli.TestCLI testMethod=test_start_with_unexistent_file_path>
>    def test_start_with_unexistent_file_path(self):
>        argv = ['bin/vint', 'path/to/unexistent']
>>       self.assertExitWithFailure(argv)
>test/unit/vint/linting/test_cli.py:41: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/unit/vint/linting/test_cli.py:29: in assertExitWithFailure
>    cli.start()
>vint/linting/cli.py:21: in start
>    env = self._build_env(sys.argv)
>vint/linting/cli.py:103: in _build_env
>    cmdargs = self._build_cmdargs(argv)
>vint/linting/cli.py:92: in _build_cmdargs
>    parser = self._build_argparser()
>vint/linting/cli.py:68: in _build_argparser
>    parser.add_argument('-v', '--version', action='version', version=self._get_version())
>vint/linting/cli.py:149: in _get_version
>    version = pkg_resources.require('vim-vint')[0].version
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:888: in require
>    needed = self.resolve(parse_requirements(requirements))
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>    def resolve(self, requirements, env=None, installer=None,
>                replace_conflicting=False, extras=None):
>        """List all distributions needed to (recursively) meet `requirements`
>    
>            `requirements` must be a sequence of ``Requirement`` objects.  `env`,
>            if supplied, should be an ``Environment`` instance.  If
>            not supplied, it defaults to all distributions available within any
>            entry or distribution in the working set.  `installer`, if supplied,
>            will be invoked with each requirement that cannot be met by an
>            already-installed distribution; it should return a ``Distribution`` or
>            ``None``.
>    
>            Unless `replace_conflicting=True`, raises a VersionConflict exception
>            if
>            any requirements are found on the path that have the correct name but
>            the wrong version.  Otherwise, if an `installer` is supplied it will be
>            invoked to obtain the correct version of the requirement and activate
>            it.
>    
>            `extras` is a list of the extras to be used with these requirements.
>            This is important because extra requirements may look like `my_req;
>            extra = "my_extra"`, which would otherwise be interpreted as a purely
>            optional requirement.  Instead, we want to be able to assert that these
>            requirements are truly required.
>            """
>    
>        # set up the stack
>        requirements = list(requirements)[::-1]
>        # set of processed requirements
>        processed = {}
>        # key -> dist
>        best = {}
>        to_activate = []
>    
>        req_extras = _ReqExtras()
>    
>        # Mapping of requirement to set of distributions that required it;
>        # useful for reporting info about conflicts.
>        required_by = collections.defaultdict(set)
>    
>        while requirements:
>            # process dependencies breadth-first
>            req = requirements.pop(0)
>            if req in processed:
>                # Ignore cyclic or redundant dependencies
>                continue
>    
>            if not req_extras.markers_pass(req, extras):
>                continue
>    
>            dist = best.get(req.key)
>            if dist is None:
>                # Find the best distribution and add it to the map
>                dist = self.by_key.get(req.key)
>                if dist is None or (dist not in req and replace_conflicting):
>                    ws = self
>                    if env is None:
>                        if dist is None:
>                            env = Environment(self.entries)
>                        else:
>                            # Use an empty environment and workingset to avoid
>                            # any further conflicts with the conflicting
>                            # distribution
>                            env = Environment([])
>                            ws = WorkingSet([])
>                    dist = best[req.key] = env.best_match(
>                        req, ws, installer,
>                        replace_conflicting=replace_conflicting
>                    )
>                    if dist is None:
>                        requirers = required_by.get(req, None)
>                        raise DistributionNotFound(req, requirers)
>                to_activate.append(dist)
>            if dist not in req:
>                # Oops, the "best" so far conflicts with a dependency
>                dependent_req = required_by[req]
>>               raise VersionConflict(dist, req).with_context(dependent_req)
>E               pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:779: ContextualVersionConflict
>___________________ TestCLI.test_start_with_valid_file_path ____________________
>self = <test.unit.vint.linting.test_cli.TestCLI testMethod=test_start_with_valid_file_path>
>    def test_start_with_valid_file_path(self):
>        argv = ['bin/vint', 'test/fixture/cli/valid1.vim']
>>       self.assertExitWithSuccess(argv)
>test/unit/vint/linting/test_cli.py:46: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>test/unit/vint/linting/test_cli.py:20: in assertExitWithSuccess
>    cli.start()
>vint/linting/cli.py:21: in start
>    env = self._build_env(sys.argv)
>vint/linting/cli.py:103: in _build_env
>    cmdargs = self._build_cmdargs(argv)
>vint/linting/cli.py:92: in _build_cmdargs
>    parser = self._build_argparser()
>vint/linting/cli.py:68: in _build_argparser
>    parser.add_argument('-v', '--version', action='version', version=self._get_version())
>vint/linting/cli.py:149: in _get_version
>    version = pkg_resources.require('vim-vint')[0].version
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:888: in require
>    needed = self.resolve(parse_requirements(requirements))
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>    def resolve(self, requirements, env=None, installer=None,
>                replace_conflicting=False, extras=None):
>        """List all distributions needed to (recursively) meet `requirements`
>    
>            `requirements` must be a sequence of ``Requirement`` objects.  `env`,
>            if supplied, should be an ``Environment`` instance.  If
>            not supplied, it defaults to all distributions available within any
>            entry or distribution in the working set.  `installer`, if supplied,
>            will be invoked with each requirement that cannot be met by an
>            already-installed distribution; it should return a ``Distribution`` or
>            ``None``.
>    
>            Unless `replace_conflicting=True`, raises a VersionConflict exception
>            if
>            any requirements are found on the path that have the correct name but
>            the wrong version.  Otherwise, if an `installer` is supplied it will be
>            invoked to obtain the correct version of the requirement and activate
>            it.
>    
>            `extras` is a list of the extras to be used with these requirements.
>            This is important because extra requirements may look like `my_req;
>            extra = "my_extra"`, which would otherwise be interpreted as a purely
>            optional requirement.  Instead, we want to be able to assert that these
>            requirements are truly required.
>            """
>    
>        # set up the stack
>        requirements = list(requirements)[::-1]
>        # set of processed requirements
>        processed = {}
>        # key -> dist
>        best = {}
>        to_activate = []
>    
>        req_extras = _ReqExtras()
>    
>        # Mapping of requirement to set of distributions that required it;
>        # useful for reporting info about conflicts.
>        required_by = collections.defaultdict(set)
>    
>        while requirements:
>            # process dependencies breadth-first
>            req = requirements.pop(0)
>            if req in processed:
>                # Ignore cyclic or redundant dependencies
>                continue
>    
>            if not req_extras.markers_pass(req, extras):
>                continue
>    
>            dist = best.get(req.key)
>            if dist is None:
>                # Find the best distribution and add it to the map
>                dist = self.by_key.get(req.key)
>                if dist is None or (dist not in req and replace_conflicting):
>                    ws = self
>                    if env is None:
>                        if dist is None:
>                            env = Environment(self.entries)
>                        else:
>                            # Use an empty environment and workingset to avoid
>                            # any further conflicts with the conflicting
>                            # distribution
>                            env = Environment([])
>                            ws = WorkingSet([])
>                    dist = best[req.key] = env.best_match(
>                        req, ws, installer,
>                        replace_conflicting=replace_conflicting
>                    )
>                    if dist is None:
>                        requirers = required_by.get(req, None)
>                        raise DistributionNotFound(req, requirers)
>                to_activate.append(dist)
>            if dist not in req:
>                # Oops, the "best" so far conflicts with a dependency
>                dependent_req = required_by[req]
>>               raise VersionConflict(dist, req).with_context(dependent_req)
>E               pkg_resources.ContextualVersionConflict: (PyYAML 4.2b4 (/usr/lib64/python3.7/site-packages), Requirement.parse('PyYAML~=3.11'), {'vim-vint'})
>/usr/lib/python3.7/site-packages/pkg_resources/__init__.py:779: ContextualVersionConflict
>============== 14 failed, 254 passed, 1 skipped in 29.18 seconds ===============
>RPM build errors:
>error: Bad exit status from /var/tmp/rpm-tmp.S8UlnC (%check)
>    Bad exit status from /var/tmp/rpm-tmp.S8UlnC (%check)
>Child return code was: 1
>EXCEPTION: [Error()]
>Traceback (most recent call last):
>  File "/usr/lib/python3.6/site-packages/mockbuild/trace_decorator.py", line 89, in trace
>    result = func(*args, **kw)
>  File "/usr/lib/python3.6/site-packages/mockbuild/util.py", line 582, in do
>    raise exception.Error("Command failed. See logs for output.\n # %s" % (command,), child.returncode)
>mockbuild.exception.Error: Command failed. See logs for output.
> # bash --login -c /usr/bin/rpmbuild -bb --target noarch --nodeps /builddir/build/SPECS/vint.spec

Actions: View

Attachments on bug 1606649: 1468877 | 1468878 | 1468879