| # pylint: disable=g-backslash-continuation | |
| # Copyright 2022 The Bazel Authors. All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """Tests the mod command.""" | |
| import json | |
| import os | |
| import tempfile | |
| from typing import Dict, List, Optional, Union | |
| from absl.testing import absltest | |
| from src.test.py.bazel import test_base | |
| from src.test.py.bazel.bzlmod.test_utils import BazelRegistry | |
| from src.test.py.bazel.bzlmod.test_utils import scratchFile | |
| class ModCommandTest(test_base.TestBase): | |
| """Test class for the mod command.""" | |
| def setUp(self): | |
| test_base.TestBase.setUp(self) | |
| self.registries_work_dir = tempfile.mkdtemp(dir=self._test_cwd) | |
| self.main_registry = BazelRegistry( | |
| os.path.join(self.registries_work_dir, 'main') | |
| ) | |
| self.main_registry.start() | |
| self.main_registry.setModuleBasePath('projects') | |
| self.projects_dir = self.main_registry.projects | |
| self.maxDiff = None # there are some long diffs in this test | |
| self.ScratchFile( | |
| '.bazelrc', | |
| [ | |
| # In ipv6 only network, this has to be enabled. | |
| # 'startup --host_jvm_args=-Djava.net.preferIPv6Addresses=true', | |
| 'mod --registry=' + self.main_registry.getURL(), | |
| # We need to have BCR here to make sure built-in modules like | |
| # bazel_tools can work. | |
| 'mod --registry=https://bcr.bazel.build', | |
| # Disable yanked version check so we are not affected BCR changes. | |
| 'mod --allow_yanked_versions=all', | |
| # Make sure Bazel CI tests pass in all environments | |
| 'mod --charset=ascii', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'module(name = "my_project", version = "1.0")', | |
| '', | |
| 'bazel_dep(name = "foo", version = "1.0", repo_name = "foo1")', | |
| 'bazel_dep(name = "foo", version = "2.0", repo_name = "foo2")', | |
| 'bazel_dep(name = "ext", version = "1.0")', | |
| 'bazel_dep(name = "ext2", version = "1.0")', | |
| 'multiple_version_override(', | |
| ' module_name= "foo",', | |
| ' versions = ["1.0", "2.0"],', | |
| ')', | |
| 'ext = use_extension("@ext//:ext.bzl", "ext")', | |
| 'use_repo(ext, myrepo="repo1")', | |
| 'ext2 = use_extension("@ext2//:ext.bzl", "ext")', | |
| 'ext2.dep(name="repo1")', | |
| 'use_repo(ext2, myrepo2="repo1")', | |
| ], | |
| ) | |
| self.main_registry.createShModule( | |
| 'foo', | |
| '1.0', | |
| {'bar': '1.0', 'ext': '1.0'}, | |
| {'bar': 'bar_from_foo1'}, | |
| extra_module_file_contents=[ | |
| 'my_ext = use_extension("@ext//:ext.bzl", "ext")', | |
| 'my_ext.dep(name="repo1")', | |
| 'my_ext.dep(name="repo2")', | |
| 'my_ext.dep(name="repo5")', | |
| 'use_repo(my_ext, my_repo1="repo1")', | |
| ], | |
| ) | |
| self.main_registry.createShModule( | |
| 'foo', | |
| '2.0', | |
| {'bar': '2.0', 'ext': '1.0'}, | |
| {'bar': 'bar_from_foo2', 'ext': 'ext_mod'}, | |
| extra_module_file_contents=[ | |
| 'my_ext = use_extension("@ext_mod//:ext.bzl", "ext")', | |
| 'my_ext.dep(name="repo4")', | |
| 'use_repo(my_ext, my_repo3="repo3", my_repo4="repo4")', | |
| ], | |
| ) | |
| self.main_registry.createShModule('bar', '1.0', {'ext': '1.0'}) | |
| self.main_registry.createShModule( | |
| 'bar', | |
| '2.0', | |
| {'ext': '1.0', 'ext2': '1.0'}, | |
| extra_module_file_contents=[ | |
| 'my_ext = use_extension("@ext//:ext.bzl", "ext")', | |
| 'my_ext.dep(name="repo3")', | |
| 'use_repo(my_ext, my_repo3="repo3")', | |
| 'my_ext2 = use_extension("@ext2//:ext.bzl", "ext")', | |
| 'my_ext2.dep(name="repo3")', | |
| 'use_repo(my_ext2, my_repo2="repo3")', | |
| ( | |
| 'http_file =' | |
| ' use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl",' | |
| ' "http_file")' | |
| ), | |
| ( | |
| 'http_file(name="file", url="https://example.com/",' | |
| ' integrity="sha256-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN/20=")' | |
| ), | |
| ], | |
| ) | |
| ext_src = [ | |
| 'def _data_repo_impl(ctx): ctx.file("BUILD")', | |
| 'data_repo = repository_rule(_data_repo_impl,', | |
| ' attrs={"data":attr.string()},', | |
| ')', | |
| 'def _ext_impl(ctx):', | |
| ' deps = {dep.name: 1 for mod in ctx.modules for dep in mod.tags.dep}', | |
| ' if "fail" in deps:', | |
| ' fail("ext failed")', | |
| ' for dep in deps:', | |
| ' data_repo(name=dep, data="requested repo")', | |
| 'ext=module_extension(_ext_impl,', | |
| ' tag_classes={"dep":tag_class(attrs={"name":attr.string()})},', | |
| ')', | |
| ] | |
| self.main_registry.createLocalPathModule('ext', '1.0', 'ext') | |
| scratchFile(self.projects_dir.joinpath('ext', 'BUILD')) | |
| scratchFile(self.projects_dir.joinpath('ext', 'ext.bzl'), ext_src) | |
| self.main_registry.createLocalPathModule('ext2', '1.0', 'ext2') | |
| scratchFile(self.projects_dir.joinpath('ext2', 'BUILD')) | |
| scratchFile(self.projects_dir.joinpath('ext2', 'ext.bzl'), ext_src) | |
| def tearDown(self): | |
| self.main_registry.stop() | |
| test_base.TestBase.tearDown(self) | |
| def testGraph(self): | |
| _, stdout, _ = self.RunBazel(['mod', 'graph'], rstrip=True) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '<root> (my_project@1.0)', | |
| '|___ext@1.0', | |
| '|___ext2@1.0', | |
| '|___foo@1.0', | |
| '| |___ext@1.0 (*)', | |
| '| |___bar@2.0', | |
| '| |___ext@1.0 (*)', | |
| '| |___ext2@1.0 (*)', | |
| '|___foo@2.0', | |
| ' |___bar@2.0 (*)', | |
| ' |___ext@1.0 (*)', | |
| '', | |
| ], | |
| 'wrong output in graph query', | |
| ) | |
| def testGraphWithExtensions(self): | |
| _, stdout, _ = self.RunBazel( | |
| ['mod', 'graph', '--extension_info=all'], rstrip=True | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '<root> (my_project@1.0)', | |
| '|___$@@ext+//:ext.bzl%ext', | |
| '| |___repo1', | |
| '| |...repo2', | |
| '| |...repo5', | |
| '|___$@@ext2+//:ext.bzl%ext', | |
| '| |___repo1', | |
| '|___ext@1.0', | |
| '|___ext2@1.0', | |
| '|___foo@1.0', | |
| '| |___$@@ext+//:ext.bzl%ext ...', | |
| '| | |___repo1', | |
| '| |___ext@1.0 (*)', | |
| '| |___bar@2.0', | |
| ( | |
| '| ' | |
| ' |___$@@bar+//:MODULE.bazel%@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ' http_file' | |
| ), | |
| '| | |___file', | |
| '| |___$@@ext+//:ext.bzl%ext ...', | |
| '| | |___repo3', | |
| '| |___$@@ext2+//:ext.bzl%ext ...', | |
| '| | |___repo3', | |
| '| |___ext@1.0 (*)', | |
| '| |___ext2@1.0 (*)', | |
| '|___foo@2.0', | |
| ' |___$@@ext+//:ext.bzl%ext ...', | |
| ' | |___repo3', | |
| ' | |___repo4', | |
| ' |___bar@2.0 (*)', | |
| ' |___ext@1.0 (*)', | |
| '', | |
| ], | |
| 'wrong output in graph with extensions query', | |
| ) | |
| def testGraphWithExtensionFilter(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'graph', | |
| '--extension_info=repos', | |
| '--extension_filter=@ext//:ext.bzl%ext', | |
| ], | |
| rstrip=True, | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '<root> (my_project@1.0)', | |
| '|___$@@ext+//:ext.bzl%ext', | |
| '| |___repo1', | |
| '|___foo@1.0 #', | |
| '| |___$@@ext+//:ext.bzl%ext', | |
| '| | |___repo1', | |
| '| |___bar@2.0 #', | |
| '| |___$@@ext+//:ext.bzl%ext', | |
| '| |___repo3', | |
| '|___foo@2.0 #', | |
| ' |___$@@ext+//:ext.bzl%ext', | |
| ' | |___repo3', | |
| ' | |___repo4', | |
| ' |___bar@2.0 #', | |
| ' |___$@@ext+//:ext.bzl%ext', | |
| ' |___repo3', | |
| '', | |
| ], | |
| 'wrong output in graph query with extension filter specified', | |
| ) | |
| def testGraphWithFailingExtensions(self): | |
| # Force ext2 to fail. | |
| with open(self.Path('MODULE.bazel'), 'a+') as f: | |
| f.write("ext2.dep(name = 'repo2')\n") | |
| f.write("ext2.dep(name = 'fail')\n") | |
| exit_code, stdout, stderr = self.RunBazel( | |
| ['mod', 'graph', '--extension_info=all'], | |
| rstrip=True, | |
| allow_failure=True, | |
| ) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| self.assertIn( | |
| 'ERROR: Results may be incomplete as 1 extension failed.', stderr | |
| ) | |
| self.assertIn('\t\tfail("ext failed")', stderr) | |
| self.assertIn('Error in fail: ext failed', stderr) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '<root> (my_project@1.0)', | |
| '|___$@@ext+//:ext.bzl%ext', | |
| '| |___repo1', | |
| '| |...repo2', | |
| '| |...repo5', | |
| '|___$@@ext2+//:ext.bzl%ext', | |
| '| |___repo1', | |
| '|___ext@1.0', | |
| '|___ext2@1.0', | |
| '|___foo@1.0', | |
| '| |___$@@ext+//:ext.bzl%ext ...', | |
| '| | |___repo1', | |
| '| |___ext@1.0 (*)', | |
| '| |___bar@2.0', | |
| ( | |
| '| ' | |
| ' |___$@@bar+//:MODULE.bazel%@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ' http_file' | |
| ), | |
| '| | |___file', | |
| '| |___$@@ext+//:ext.bzl%ext ...', | |
| '| | |___repo3', | |
| '| |___$@@ext2+//:ext.bzl%ext ...', | |
| '| | |___repo3', | |
| '| |___ext@1.0 (*)', | |
| '| |___ext2@1.0 (*)', | |
| '|___foo@2.0', | |
| ' |___$@@ext+//:ext.bzl%ext ...', | |
| ' | |___repo3', | |
| ' | |___repo4', | |
| ' |___bar@2.0 (*)', | |
| ' |___ext@1.0 (*)', | |
| '', | |
| ], | |
| 'wrong output in graph with extensions query', | |
| ) | |
| def testShowExtensionAllUsages(self): | |
| _, stdout, _ = self.RunBazel( | |
| ['mod', 'show_extension', '@ext//:ext.bzl%ext'], rstrip=True | |
| ) | |
| self.assertRegex( | |
| stdout.pop(9), r'^## Usage in <root> from .*MODULE\.bazel:11$' | |
| ) | |
| self.assertRegex( | |
| stdout.pop(14), r'^## Usage in foo@1.0 from .*MODULE\.bazel:8$' | |
| ) | |
| self.assertRegex( | |
| stdout.pop(22), r'^## Usage in foo@2.0 from .*MODULE\.bazel:8$' | |
| ) | |
| self.assertRegex( | |
| stdout.pop(29), r'^## Usage in bar@2.0 from .*MODULE\.bazel:8$' | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '## @@ext+//:ext.bzl%ext:', | |
| '', | |
| 'Fetched repositories:', | |
| ' - repo1 (imported by <root>, foo@1.0)', | |
| ' - repo3 (imported by bar@2.0, foo@2.0)', | |
| ' - repo4 (imported by foo@2.0)', | |
| ' - repo2', | |
| ' - repo5', | |
| '', | |
| # pop(9) | |
| 'use_repo(', | |
| ' ext,', | |
| ' myrepo="repo1",', | |
| ')', | |
| '', | |
| # pop(14) | |
| 'ext.dep(name="repo1")', | |
| 'ext.dep(name="repo2")', | |
| 'ext.dep(name="repo5")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo1="repo1",', | |
| ')', | |
| '', | |
| # pop(22) | |
| 'ext.dep(name="repo4")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo3="repo3",', | |
| ' my_repo4="repo4",', | |
| ')', | |
| '', | |
| # pop(29) | |
| 'ext.dep(name="repo3")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo3="repo3",', | |
| ')', | |
| '', | |
| ], | |
| 'wrong output in show_extension query with all usages', | |
| ) | |
| def testShowExtensionSomeExtensionsSomeUsages(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_extension', | |
| '@ext//:ext.bzl%ext', | |
| '@ext2//:ext.bzl%ext', | |
| '--extension_usages=@foo2,bar@2.0', | |
| ], | |
| rstrip=True, | |
| ) | |
| self.assertRegex( | |
| stdout.pop(9), r'^## Usage in foo@2.0 from .*MODULE\.bazel:8$' | |
| ) | |
| self.assertRegex( | |
| stdout.pop(16), r'^## Usage in bar@2.0 from .*MODULE\.bazel:8$' | |
| ) | |
| self.assertRegex( | |
| stdout.pop(28), r'^## Usage in bar@2.0 from .*MODULE\.bazel:11$' | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '## @@ext+//:ext.bzl%ext:', | |
| '', | |
| 'Fetched repositories:', | |
| ' - repo1 (imported by <root>, foo@1.0)', | |
| ' - repo3 (imported by bar@2.0, foo@2.0)', | |
| ' - repo4 (imported by foo@2.0)', | |
| ' - repo2', | |
| ' - repo5', | |
| '', | |
| # pop(9) | |
| 'ext.dep(name="repo4")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo3="repo3",', | |
| ' my_repo4="repo4",', | |
| ')', | |
| '', | |
| # pop(16) | |
| 'ext.dep(name="repo3")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo3="repo3",', | |
| ')', | |
| '', | |
| '## @@ext2+//:ext.bzl%ext:', | |
| '', | |
| 'Fetched repositories:', | |
| ' - repo1 (imported by <root>)', | |
| ' - repo3 (imported by bar@2.0)', | |
| '', | |
| # pop(28) | |
| 'ext.dep(name="repo3")', | |
| 'use_repo(', | |
| ' ext,', | |
| ' my_repo2="repo3",', | |
| ')', | |
| '', | |
| ], | |
| 'Wrong output in the show with some extensions and some usages query.', | |
| ) | |
| def testShowExtensionWithUnknownRepo(self): | |
| _, _, stderr = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_extension', | |
| '@@unknown//foo:bar.bzl%x', | |
| ], | |
| allow_failure=True, | |
| rstrip=True, | |
| ) | |
| self.assertIn( | |
| 'ERROR: In extension argument @@unknown//foo:bar.bzl%x: No module with ' | |
| 'the canonical repo name @@unknown exists in the dependency graph.', | |
| '\n'.join(stderr), | |
| ) | |
| def testShowExtensionWithUnknownExtension(self): | |
| _, _, stderr = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_extension', | |
| '@ext//foo:unknown.bzl%x', | |
| ], | |
| allow_failure=True, | |
| rstrip=True, | |
| ) | |
| self.assertIn( | |
| 'No extension @@ext+//foo:unknown.bzl%x exists in the dependency graph', | |
| '\n'.join(stderr), | |
| ) | |
| def testShowExtensionUseRepoRule(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_extension', | |
| ( | |
| '@@bar+//:MODULE.bazel%@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ' http_file' | |
| ), | |
| ], | |
| rstrip=True, | |
| ) | |
| self.assertRegex( | |
| stdout.pop(5), | |
| r'^## Usage in bar@2\.0 from .*MODULE\.bazel:15$', | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| ( | |
| '## @@bar+//:MODULE.bazel%@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ' http_file:' | |
| ), | |
| '', | |
| 'Fetched repositories:', | |
| ' - file (imported by bar@2.0)', | |
| '', | |
| # pop(5) | |
| ( | |
| 'http_file =' | |
| ' use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl",' | |
| ' "http_file")' | |
| ), | |
| ( | |
| 'http_file(name="file",' | |
| ' integrity="sha256-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN/20=",' | |
| ' url="https://example.com/")' | |
| ), | |
| '', | |
| ], | |
| ) | |
| def testShowModuleAndExtensionReposFromBaseModuleJson(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_repo', | |
| '--base_module=foo@2.0', | |
| '--output=streamed_jsonproto', | |
| '@bar_from_foo2', | |
| 'ext@1.0', | |
| '@my_repo3', | |
| 'bar', | |
| ], | |
| rstrip=True, | |
| ) | |
| repos = [json.loads(line) for line in stdout] | |
| ignored_attrs = { | |
| 'integrity', | |
| 'path', | |
| 'remote_module_file_urls', | |
| 'remote_module_file_integrity', | |
| 'urls', | |
| } | |
| for repo in repos: | |
| attrs = repo.get('attribute') | |
| if attrs: | |
| repo['attribute'] = [ | |
| attr | |
| for attr in attrs | |
| if attr.get('explicitlySpecified', False) | |
| and attr['name'] not in ignored_attrs | |
| ] | |
| self.assertListEqual( | |
| repos, | |
| [ | |
| { | |
| 'canonicalName': 'bar+', | |
| 'repoRuleName': 'http_archive', | |
| 'repoRuleBzlLabel': ( | |
| '@@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ), | |
| 'apparentName': '@bar_from_foo2', | |
| 'attribute': [ | |
| { | |
| 'name': 'strip_prefix', | |
| 'type': 'STRING', | |
| 'stringValue': '', | |
| 'explicitlySpecified': True, | |
| 'nodep': False, | |
| }, | |
| { | |
| 'name': 'remote_file_urls', | |
| 'type': 'STRING_LIST_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_file_integrity', | |
| 'type': 'STRING_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_patches', | |
| 'type': 'STRING_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_patch_strip', | |
| 'type': 'INTEGER', | |
| 'intValue': 0, | |
| 'explicitlySpecified': True, | |
| }, | |
| ], | |
| }, | |
| { | |
| 'canonicalName': 'ext+', | |
| 'repoRuleName': 'local_repository', | |
| 'repoRuleBzlLabel': ( | |
| '@@bazel_tools//tools/build_defs/repo:local.bzl' | |
| ), | |
| 'moduleKey': 'ext@1.0', | |
| 'attribute': [], | |
| }, | |
| { | |
| 'canonicalName': 'ext++ext+repo3', | |
| 'repoRuleName': 'data_repo', | |
| 'repoRuleBzlLabel': '@@ext+//:ext.bzl', | |
| 'apparentName': '@my_repo3', | |
| 'originalName': 'repo3', | |
| 'attribute': [ | |
| { | |
| 'name': 'data', | |
| 'type': 'STRING', | |
| 'stringValue': 'requested repo', | |
| 'nodep': False, | |
| 'explicitlySpecified': True, | |
| }, | |
| ], | |
| }, | |
| { | |
| 'canonicalName': 'bar+', | |
| 'repoRuleName': 'http_archive', | |
| 'repoRuleBzlLabel': ( | |
| '@@bazel_tools//tools/build_defs/repo:http.bzl' | |
| ), | |
| 'moduleKey': 'bar@2.0', | |
| 'attribute': [ | |
| { | |
| 'name': 'strip_prefix', | |
| 'type': 'STRING', | |
| 'stringValue': '', | |
| 'explicitlySpecified': True, | |
| 'nodep': False, | |
| }, | |
| { | |
| 'name': 'remote_file_urls', | |
| 'type': 'STRING_LIST_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_file_integrity', | |
| 'type': 'STRING_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_patches', | |
| 'type': 'STRING_DICT', | |
| 'explicitlySpecified': True, | |
| }, | |
| { | |
| 'name': 'remote_patch_strip', | |
| 'type': 'INTEGER', | |
| 'intValue': 0, | |
| 'explicitlySpecified': True, | |
| }, | |
| ], | |
| }, | |
| ], | |
| 'wrong output in the show query for module and extension-generated' | |
| ' repos', | |
| ) | |
| def testShowModuleAndExtensionReposFromBaseModule(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'show_repo', | |
| '--base_module=foo@2.0', | |
| '@bar_from_foo2', | |
| 'ext@1.0', | |
| '@my_repo3', | |
| '@my_repo4', | |
| 'bar', | |
| ], | |
| rstrip=True, | |
| ) | |
| self.assertRegex(stdout.pop(4), r'^ urls = \[".*"\],$') | |
| self.assertRegex(stdout.pop(4), r'^ integrity = ".*",$') | |
| self.assertRegex( | |
| stdout.pop(8), | |
| r'^ remote_module_file_urls = \[".*/modules/bar/2.0/MODULE.bazel"\],$', | |
| ) | |
| self.assertRegex(stdout.pop(8), r'^ remote_module_file_integrity = ".*",$') | |
| self.assertRegex(stdout.pop(15), r'^ path = ".*",$') | |
| self.assertRegex(stdout.pop(37), r'^ urls = \[".*"\],$') | |
| self.assertRegex(stdout.pop(37), r'^ integrity = ".*",$') | |
| self.assertRegex(stdout.pop(41), r'^ remote_module_file_urls = \[".*"\],$') | |
| self.assertRegex( | |
| stdout.pop(41), r'^ remote_module_file_integrity = ".*",$' | |
| ) | |
| self.assertListEqual( | |
| stdout, | |
| [ | |
| '## @bar_from_foo2:', | |
| ( | |
| 'load("@@bazel_tools//tools/build_defs/repo:http.bzl",' | |
| ' "http_archive")' | |
| ), | |
| 'http_archive(', | |
| ' name = "bar+",', | |
| # pop(4) -- urls=[...] | |
| # pop(4) -- integrity=... | |
| ' strip_prefix = "",', | |
| ' remote_patches = {},', | |
| ' remote_file_urls = {},', | |
| ' remote_file_integrity = {},', | |
| # pop(8) -- remote_module_file_urls | |
| # pop(8) -- remote_module_file_integrity | |
| ' remote_patch_strip = 0,', | |
| ')', | |
| '', | |
| '## ext@1.0:', | |
| ( | |
| 'load("@@bazel_tools//tools/build_defs/repo:local.bzl",' | |
| ' "local_repository")' | |
| ), | |
| 'local_repository(', | |
| ' name = "ext+",', | |
| # pop(15) -- path=... | |
| ')', | |
| '', | |
| '## @my_repo3:', | |
| 'load("@@ext+//:ext.bzl", "data_repo")', | |
| 'data_repo(', | |
| ' name = "ext++ext+repo3",', | |
| ' _original_name = "repo3",', | |
| ' data = "requested repo",', | |
| ')', | |
| '', | |
| '## @my_repo4:', | |
| 'load("@@ext+//:ext.bzl", "data_repo")', | |
| 'data_repo(', | |
| ' name = "ext++ext+repo4",', | |
| ' _original_name = "repo4",', | |
| ' data = "requested repo",', | |
| ')', | |
| '', | |
| '## bar@2.0:', | |
| ( | |
| 'load("@@bazel_tools//tools/build_defs/repo:http.bzl",' | |
| ' "http_archive")' | |
| ), | |
| 'http_archive(', | |
| ' name = "bar+",', | |
| # pop(37) -- urls=[...] | |
| # pop(37) -- integrity=... | |
| ' strip_prefix = "",', | |
| ' remote_patches = {},', | |
| ' remote_file_urls = {},', | |
| ' remote_file_integrity = {},', | |
| # pop(41) -- remote_module_file_urls=[...] | |
| # pop(41) -- remote_module_file_integrity=... | |
| ' remote_patch_strip = 0,', | |
| ')', | |
| '', | |
| ], | |
| 'wrong output in the show query for module and extension-generated' | |
| ' repos', | |
| ) | |
| def _parseShowRepoOutput( | |
| self, stdout: List[str] | |
| ) -> Dict[str, Union[str, List[str]]]: | |
| key_to_repo: Dict[str, Union[str, List[str]]] = {} | |
| current_key: Optional[str] = None | |
| for line in stdout: | |
| if line.startswith('## '): | |
| current_key = line[3:-1] # Remove '## ' prefix and ':' suffix. | |
| elif line.startswith(' name = "') or line.startswith( | |
| 'Builtin or overridden repo located at:' | |
| ): | |
| if current_key is None: | |
| self.fail(f'Found repo without key: {line}') | |
| if line.startswith(' name = "'): | |
| repo_name = line[ | |
| len(' name = "') : -2 | |
| ] # Remove prefix and '",' suffix. | |
| else: | |
| repo_name = 'builtin or overridden repo' | |
| if current_key in key_to_repo: | |
| if isinstance(key_to_repo[current_key], str): | |
| key_to_repo[current_key] = [key_to_repo[current_key], repo_name] | |
| else: | |
| key_to_repo[current_key].append(repo_name) | |
| else: | |
| key_to_repo[current_key] = repo_name | |
| return key_to_repo | |
| def testShowRepoAllRepos(self): | |
| _, stdout, _ = self.RunBazel( | |
| ['mod', 'show_repo', '--all_repos'], | |
| rstrip=True, | |
| ) | |
| parsed = self._parseShowRepoOutput(stdout) | |
| # Only has canonical repo names | |
| for name in parsed: | |
| self.assertTrue( | |
| name.startswith('@@'), | |
| f'Found non-canonical {name} -> {parsed[name]} in output', | |
| ) | |
| if parsed[name] != 'builtin or overridden repo': | |
| self.assertEqual( | |
| name, | |
| '@@' + parsed[name], | |
| f'Found non-canonical {name} -> {parsed[name]} in output', | |
| ) | |
| self.assertIsInstance( | |
| parsed[name], | |
| str, | |
| f'Found duplicate name in output: {name} -> {parsed[name]}', | |
| ) | |
| self.assertContainsSubset( | |
| [ | |
| # Built in | |
| '@@bazel_tools', | |
| # Has both versions of direct dependencies | |
| '@@foo+1.0', | |
| '@@foo+2.0', | |
| # Has transitive dependencies | |
| '@@bar+', | |
| # Has module repos | |
| '@@ext++ext+repo1', | |
| '@@ext++ext+repo3', | |
| ], | |
| parsed.keys(), | |
| ) | |
| self.assertNoCommonElements( | |
| ['@@', '@@<root>', '@@my_project'], | |
| parsed.keys(), | |
| 'Found main repo in output', | |
| ) | |
| self.assertNoCommonElements( | |
| ['@@foo1', '@@foo2', '@@myrepo2'], | |
| parsed.keys(), | |
| 'Found apparent repo names in output', | |
| ) | |
| def testShowRepoAllVisibleRepos(self): | |
| _, stdout, _ = self.RunBazel( | |
| ['mod', 'show_repo', '--all_visible_repos'], | |
| rstrip=True, | |
| ) | |
| parsed = self._parseShowRepoOutput(stdout) | |
| self.assertDictEqual( | |
| { | |
| '@bazel_tools': 'builtin or overridden repo', | |
| '@foo1': 'foo+1.0', | |
| '@foo2': 'foo+2.0', | |
| '@ext': 'ext+', | |
| '@ext2': 'ext2+', | |
| '@myrepo': 'ext++ext+repo1', | |
| '@myrepo2': 'ext2++ext+repo1', | |
| }, | |
| parsed, | |
| ) | |
| def testShowRepoAllVisibleReposFromBaseModule(self): | |
| _, stdout, _ = self.RunBazel( | |
| ['mod', 'show_repo', '--all_visible_repos', '--base_module=foo@2.0'], | |
| rstrip=True, | |
| ) | |
| parsed = self._parseShowRepoOutput(stdout) | |
| self.assertDictEqual( | |
| { | |
| '@bazel_tools': 'builtin or overridden repo', | |
| '@foo': 'foo+2.0', | |
| '@bar_from_foo2': 'bar+', | |
| '@ext_mod': 'ext+', | |
| '@my_repo3': 'ext++ext+repo3', | |
| '@my_repo4': 'ext++ext+repo4', | |
| }, | |
| parsed, | |
| ) | |
| def testShowRepoThrowsConflictingRepoSpecs(self): | |
| expected_msg = ( | |
| "ERROR: the 'show_repo' command requires exactly one of --all_repos," | |
| " --all_visible_repos, or a list of repo arguments. Type 'bazel help" | |
| " mod' for syntax and help." | |
| ) | |
| exit_code, _, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '--all_repos', '@foo1'], | |
| rstrip=True, | |
| allow_failure=True, | |
| ) | |
| self.assertEqual(exit_code, 2, '--all_repos args') | |
| self.assertIn(expected_msg, stderr, '--all_repos args') | |
| exit_code, _, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '@foo1', '--all_visible_repos'], | |
| rstrip=True, | |
| allow_failure=True, | |
| ) | |
| self.assertEqual(exit_code, 2, 'args --all_visible_repos') | |
| self.assertIn(expected_msg, stderr, 'args --all_visible_repos') | |
| exit_code, _, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '--all_visible_repos', '--all_repos'], | |
| rstrip=True, | |
| allow_failure=True, | |
| ) | |
| self.assertEqual(exit_code, 2, '--all_visible_repos --all_repos') | |
| self.assertIn(expected_msg, stderr, '--all_visible_repos --all_repos') | |
| def testShowRepoThrowsUnusedModule(self): | |
| _, _, stderr = self.RunBazel( | |
| ['mod', 'show_repo', 'bar@1.0', '--base_module=@foo2'], | |
| allow_failure=True, | |
| rstrip=True, | |
| ) | |
| self.assertIn( | |
| 'ERROR: In repo argument bar@1.0: Module version bar@1.0 does not' | |
| ' exist, available versions: [bar@2.0]. (Note that unused modules' | |
| " cannot be used here). Type 'bazel help mod' for syntax and help.", | |
| stderr, | |
| ) | |
| # fix for https://github.com/bazelbuild/bazel/issues/22587 | |
| def testShowRepoThrowsNonexistentRepo(self): | |
| _, _, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '<root>'], | |
| allow_failure=True, | |
| rstrip=True, | |
| ) | |
| self.assertIn( | |
| "ERROR: In repo argument <root>: no such repo. Type 'bazel help mod' " | |
| 'for syntax and help.', | |
| stderr, | |
| ) | |
| # fix for https://github.com/bazelbuild/bazel/issues/27233 | |
| def testShowRepoBazelTools(self): | |
| exit_code, stdout, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '@bazel_tools'], | |
| rstrip=True, | |
| ) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| stdout = '\n'.join(stdout) | |
| self.assertIn('## @bazel_tools:', stdout) | |
| self.assertIn('Builtin or overridden repo located at: ', stdout) | |
| self.assertIn('/embedded_tools', stdout) | |
| def testShowRepoBazelToolsJson(self): | |
| # @bazel_tools should be omitted from proto outputs | |
| exit_code, stdout, stderr = self.RunBazel( | |
| ['mod', 'show_repo', '--output=streamed_jsonproto', '@bazel_tools'], | |
| rstrip=True, | |
| ) | |
| self.AssertExitCode(exit_code, 0, stderr) | |
| stdout = '\n'.join(stdout) | |
| self.assertEqual('', stdout) | |
| def testDumpRepoMapping(self): | |
| _, stdout, _ = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'dump_repo_mapping', | |
| '', | |
| 'foo+2.0', | |
| ], | |
| ) | |
| root_mapping, foo_mapping = [json.loads(l) for l in stdout] | |
| self.assertContainsSubset( | |
| { | |
| 'my_project': '', | |
| 'foo1': 'foo+1.0', | |
| 'foo2': 'foo+2.0', | |
| 'myrepo2': 'ext2++ext+repo1', | |
| 'bazel_tools': 'bazel_tools', | |
| }.items(), | |
| root_mapping.items(), | |
| ) | |
| self.assertContainsSubset( | |
| { | |
| 'foo': 'foo+2.0', | |
| 'ext_mod': 'ext+', | |
| 'my_repo3': 'ext++ext+repo3', | |
| 'bazel_tools': 'bazel_tools', | |
| }.items(), | |
| foo_mapping.items(), | |
| ) | |
| def testDumpRepoMappingThrowsNoRepos(self): | |
| _, _, stderr = self.RunBazel( | |
| ['mod', 'dump_repo_mapping'], | |
| allow_failure=True, | |
| ) | |
| self.assertIn( | |
| "ERROR: No repository name(s) specified. Type 'bazel help mod' for" | |
| ' syntax and help.', | |
| stderr, | |
| ) | |
| def testDumpRepoMappingThrowsInvalidRepoName(self): | |
| _, _, stderr = self.RunBazel( | |
| ['mod', 'dump_repo_mapping', '{}'], | |
| allow_failure=True, | |
| ) | |
| self.assertIn( | |
| "ERROR: invalid repository name '{}': repo names may contain only A-Z," | |
| " a-z, 0-9, '-', '_', '.' and '+'. Type 'bazel help mod' for syntax" | |
| ' and help.', | |
| stderr, | |
| ) | |
| def testDumpRepoMappingThrowsUnknownRepoName(self): | |
| _, _, stderr = self.RunBazel( | |
| ['mod', 'dump_repo_mapping', 'does_not_exist'], | |
| allow_failure=True, | |
| ) | |
| self.assertIn( | |
| "ERROR: Repositories not found: does_not_exist. Type 'bazel help mod'" | |
| ' for syntax and help.', | |
| stderr, | |
| ) | |
| def testModTidy(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext1 = use_extension("//:extension.bzl", "ext1")', | |
| 'use_repo(ext1, "dep", "indirect_dep")', | |
| 'ext1_isolated = use_extension(', | |
| ' "//:extension.bzl",', | |
| ' "ext1",', | |
| ' isolate = True,', | |
| ')', | |
| 'use_repo(', | |
| ' ext1_isolated,', | |
| ' my_dep = "dep",', | |
| ' my_missing_dep = "missing_dep",', | |
| ' my_indirect_dep = "indirect_dep",', | |
| ')', | |
| ( | |
| 'ext2 = use_extension("//:extension.bzl", "ext2",' | |
| ' dev_dependency = True)' | |
| ), | |
| 'use_repo(ext2, "dev_dep", "indirect_dev_dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext1_impl(ctx):', | |
| ' print("ext1 is being evaluated")', | |
| ' repo_rule(name="dep")', | |
| ' repo_rule(name="missing_dep")', | |
| ' repo_rule(name="indirect_dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep", "missing_dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext1 = module_extension(implementation=_ext1_impl)', | |
| '', | |
| 'def _ext2_impl(ctx):', | |
| ' print("ext2 is being evaluated")', | |
| ' repo_rule(name="dev_dep")', | |
| ' repo_rule(name="missing_dev_dep")', | |
| ' repo_rule(name="indirect_dev_dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=[],', | |
| ( | |
| ' root_module_direct_dev_deps=["dev_dep",' | |
| ' "missing_dev_dep"],' | |
| ), | |
| ' )', | |
| '', | |
| 'ext2 = module_extension(implementation=_ext2_impl)', | |
| ], | |
| ) | |
| # Create a lockfile and let the extension evaluations emit fixup warnings. | |
| _, _, stderr = self.RunBazel([ | |
| 'mod', | |
| 'deps', | |
| '--lockfile_mode=update', | |
| '--experimental_isolated_extension_usages', | |
| ]) | |
| stderr = '\n'.join(stderr) | |
| self.assertIn('ext1 is being evaluated', stderr) | |
| self.assertIn('ext2 is being evaluated', stderr) | |
| self.assertIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Run bazel mod tidy to fix the imports. | |
| _, stdout, stderr = self.RunBazel([ | |
| 'mod', | |
| 'tidy', | |
| '--lockfile_mode=update', | |
| '--experimental_isolated_extension_usages', | |
| ]) | |
| self.assertEqual([], stdout) | |
| stderr = '\n'.join(stderr) | |
| # The extensions should not be reevaluated by the command. | |
| self.assertNotIn('ext1 is being evaluated', stderr) | |
| self.assertNotIn('ext2 is being evaluated', stderr) | |
| # bazel mod tidy doesn't show fixup warnings. | |
| self.assertNotIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertNotIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Fixes are reported. | |
| self.assertIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext1', stderr | |
| ) | |
| self.assertIn( | |
| "INFO: Updated use_repo calls for isolated usage 'ext1_isolated' of" | |
| ' @//:extension.bzl%ext1', | |
| stderr, | |
| ) | |
| self.assertIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext2', stderr | |
| ) | |
| # Rerun bazel mod deps to check that the fixup warnings are gone | |
| # and the lockfile is up-to-date. | |
| _, _, stderr = self.RunBazel([ | |
| 'mod', | |
| 'deps', | |
| '--lockfile_mode=error', | |
| '--experimental_isolated_extension_usages', | |
| ]) | |
| stderr = '\n'.join(stderr) | |
| self.assertNotIn('ext1 is being evaluated', stderr) | |
| self.assertNotIn('ext2 is being evaluated', stderr) | |
| self.assertNotIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertNotIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Verify that use_repo statements have been updated. | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext1 = use_extension("//:extension.bzl", "ext1")', | |
| 'use_repo(ext1, "dep", "missing_dep")', | |
| '', | |
| 'ext1_isolated = use_extension(', | |
| ' "//:extension.bzl",', | |
| ' "ext1",', | |
| ' isolate = True,', | |
| ')', | |
| 'use_repo(', | |
| ' ext1_isolated,', | |
| ' my_dep = "dep",', | |
| ' my_missing_dep = "missing_dep",', | |
| ')', | |
| '', | |
| ( | |
| 'ext2 = use_extension("//:extension.bzl", "ext2",' | |
| ' dev_dependency = True)' | |
| ), | |
| 'use_repo(ext2, "dev_dep", "missing_dev_dep")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyAlwaysFormatsModuleFile(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext=use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext_impl(ctx):', | |
| ' repo_rule(name="dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| ], | |
| ) | |
| # Verify that bazel mod tidy formats the MODULE.bazel file | |
| # even if there are no use_repos to fix. | |
| self.RunBazel(['mod', 'tidy']) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| # This newline is from ScratchFile. | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyNoop(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext_impl(ctx):', | |
| ' repo_rule(name="dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| ], | |
| ) | |
| # Verify that bazel mod tidy doesn't fail or change the file. | |
| self.RunBazel(['mod', 'tidy']) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| # This newline is from ScratchFile. | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyWithNonRegistryOverride(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'bazel_dep(name = "foo", version = "1.2.3")', | |
| 'local_path_override(module_name = "foo", path = "foo")', | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def _ext_impl(ctx):', | |
| ' pass', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'foo/MODULE.bazel', ['module(name = "foo", version = "1.2.3")'] | |
| ) | |
| # Verify that bazel mod tidy doesn't fail without the lockfile. | |
| self.RunBazel(['mod', 'tidy']) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'bazel_dep(name = "foo", version = "1.2.3")', | |
| 'local_path_override(', | |
| ' module_name = "foo",', | |
| ' path = "foo",', | |
| ')', | |
| '', | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| # This newline is from ScratchFile. | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| # Verify that bazel mod tidy doesn't fail with the lockfile. | |
| self.RunBazel(['mod', 'tidy']) | |
| def testModTidyWithoutUsages(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'module( name = "foo", version = "1.2.3")', | |
| ], | |
| ) | |
| self.RunBazel(['mod', 'tidy']) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'module(', | |
| ' name = "foo",', | |
| ' version = "1.2.3",', | |
| ')', | |
| # This newline is from ScratchFile. | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyFailsOnExtensionFailure(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def _ext_impl(ctx):', | |
| ' "foo"[3]', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| ], | |
| ) | |
| # Verify that bazel mod tidy fails if an extension fails to execute. | |
| exit_code, _, stderr = self.RunBazel(['mod', 'tidy'], allow_failure=True) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| stderr = '\n'.join(stderr) | |
| self.assertIn('//:extension.bzl', stderr) | |
| self.assertIn('Error: index out of range', stderr) | |
| self.assertNotIn('buildozer', stderr) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyKeepGoing(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext1 = use_extension("//:extension.bzl", "ext1")', | |
| 'use_repo(ext1, "dep", "indirect_dep")', | |
| 'ext2 = use_extension("//:extension.bzl", "ext2")', | |
| 'use_repo(ext2, "other_dep", "other_indirect_dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext1_impl(ctx):', | |
| ' print("ext1 is being evaluated")', | |
| ' repo_rule(name="dep")', | |
| ' repo_rule(name="missing_dep")', | |
| ' repo_rule(name="indirect_dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep", "missing_dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext1 = module_extension(implementation=_ext1_impl)', | |
| '', | |
| 'def _ext2_impl(ctx):', | |
| ' print("ext2 is being evaluated")', | |
| ' fail("ext2 failed")', | |
| '', | |
| 'ext2 = module_extension(implementation=_ext2_impl)', | |
| ], | |
| ) | |
| # Create a lockfile and let the extension evaluations emit fixup warnings. | |
| exit_code, _, stderr = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'deps', | |
| '--lockfile_mode=update', | |
| ], | |
| allow_failure=True, | |
| ) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| stderr = '\n'.join(stderr) | |
| self.assertIn('ext1 is being evaluated', stderr) | |
| self.assertIn('ext2 is being evaluated', stderr) | |
| self.assertIn('Error in fail: ext2 failed', stderr) | |
| self.assertIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Run bazel mod tidy to fix the imports. | |
| exit_code, stdout, stderr = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'tidy', | |
| '--lockfile_mode=update', | |
| ], | |
| allow_failure=True, | |
| ) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| self.assertEqual([], stdout) | |
| self.assertIn('ERROR: Failed to process 1 extension due to errors.', stderr) | |
| stderr = '\n'.join(stderr) | |
| # The passing extension should not be reevaluated by the command. | |
| self.assertNotIn('ext1 is being evaluated', stderr) | |
| self.assertIn('ext2 is being evaluated', stderr) | |
| # baze mod tidy doesn't show fixup warnings. | |
| self.assertNotIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertNotIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Fixes are reported. | |
| self.assertIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext1', stderr | |
| ) | |
| self.assertNotIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext2', stderr | |
| ) | |
| # Rerun bazel mod deps to check that the fixup warnings are gone | |
| # and the lockfile is up-to-date. | |
| exit_code, _, stderr = self.RunBazel( | |
| [ | |
| 'mod', | |
| 'deps', | |
| '--lockfile_mode=error', | |
| ], | |
| allow_failure=True, | |
| ) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| # The exit code if the build fails due to a lockfile that is not up-to-date. | |
| self.AssertNotExitCode(exit_code, 48, stderr) | |
| stderr = '\n'.join(stderr) | |
| self.assertNotIn('ext1 is being evaluated', stderr) | |
| self.assertIn('ext2 is being evaluated', stderr) | |
| self.assertNotIn( | |
| 'Not imported, but reported as direct dependencies by the extension' | |
| ' (may cause the build to fail):\nmissing_dep', | |
| stderr, | |
| ) | |
| self.assertNotIn( | |
| 'Imported, but reported as indirect dependencies by the' | |
| ' extension:\nindirect_dep', | |
| stderr, | |
| ) | |
| # Verify that use_repo statements have been updated. | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext1 = use_extension("//:extension.bzl", "ext1")', | |
| 'use_repo(ext1, "dep", "missing_dep")', | |
| '', | |
| 'ext2 = use_extension("//:extension.bzl", "ext2")', | |
| 'use_repo(ext2, "other_dep", "other_indirect_dep")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyFixesInvalidImport(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "invalid_dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext_impl(ctx):', | |
| ' repo_rule(name="dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| ], | |
| ) | |
| # Verify that bazel mod tidy fixes the MODULE.bazel file even though the | |
| # extension fails after evaluation. | |
| _, _, stderr = self.RunBazel(['mod', 'tidy']) | |
| stderr = '\n'.join(stderr) | |
| self.assertIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext', stderr | |
| ) | |
| with open('MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModTidyWithIncludes(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'include("//:firstProd.MODULE.bazel")', | |
| 'include("//:secondäöüÄÖÜß🌱.MODULE.bazel")', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'firstProd.MODULE.bazel', | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep2", "bad_dep")', | |
| 'include("//:firstDev.MODULE.bazel")', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'firstDev.MODULE.bazel', | |
| [ | |
| ( | |
| 'ext_dev = use_extension("//:extension.bzl", "ext",' | |
| ' dev_dependency = True)' | |
| ), | |
| 'use_repo(ext_dev, "dev2", "bad_dev")', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'secondäöüÄÖÜß🌱.MODULE.bazel', | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "blad_dep")', | |
| ( | |
| 'ext_dev = use_extension("//:extension.bzl", "ext",' | |
| ' dev_dependency = True)' | |
| ), | |
| 'use_repo(ext_dev, "blad_dev")', | |
| 'ext2 = use_extension("//:extension.bzl", "ext2")', | |
| 'use_repo(ext2, "blaad_dep")', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| self.ScratchFile( | |
| 'extension.bzl', | |
| [ | |
| 'def impl(ctx):', | |
| ' ctx.file("WORKSPACE")', | |
| ' ctx.file("BUILD", "filegroup(name=\'lala\')")', | |
| '', | |
| 'repo_rule = repository_rule(implementation=impl)', | |
| '', | |
| 'def _ext_impl(ctx):', | |
| ' repo_rule(name="dep")', | |
| ' repo_rule(name="dep2")', | |
| ' repo_rule(name="dev")', | |
| ' repo_rule(name="dev2")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["dep", "dep2"],', | |
| ' root_module_direct_dev_deps=["dev", "dev2"],', | |
| ' )', | |
| '', | |
| 'ext = module_extension(implementation=_ext_impl)', | |
| '', | |
| 'def _ext2_impl(ctx):', | |
| ' repo_rule(name="ext2_dep")', | |
| ' return ctx.extension_metadata(', | |
| ' root_module_direct_deps=["ext2_dep"],', | |
| ' root_module_direct_dev_deps=[],', | |
| ' )', | |
| '', | |
| 'ext2 = module_extension(implementation=_ext2_impl)', | |
| ], | |
| ) | |
| _, _, stderr = self.RunBazel(['mod', 'tidy']) | |
| stderr = '\n'.join(stderr) | |
| self.assertIn( | |
| 'INFO: Updated use_repo calls for @//:extension.bzl%ext', stderr | |
| ) | |
| with open('MODULE.bazel', 'r', encoding='utf-8') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'include("//:firstProd.MODULE.bazel")', | |
| 'include("//:secondäöüÄÖÜß🌱.MODULE.bazel")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| with open('firstProd.MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| 'use_repo(ext, "dep", "dep2")', | |
| '', | |
| 'include("//:firstDev.MODULE.bazel")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| with open('firstDev.MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| ( | |
| 'ext_dev = use_extension("//:extension.bzl", "ext",' | |
| ' dev_dependency = True)' | |
| ), | |
| 'use_repo(ext_dev, "dev", "dev2")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| with open('secondäöüÄÖÜß🌱.MODULE.bazel', 'r') as module_file: | |
| self.assertEqual( | |
| [ | |
| 'ext = use_extension("//:extension.bzl", "ext")', | |
| '', | |
| ( | |
| 'ext_dev = use_extension("//:extension.bzl", "ext",' | |
| ' dev_dependency = True)' | |
| ), | |
| '', | |
| 'ext2 = use_extension("//:extension.bzl", "ext2")', | |
| 'use_repo(ext2, "ext2_dep")', | |
| '', | |
| ], | |
| module_file.read().split('\n'), | |
| ) | |
| def testModCommandWithCycleDoesNotCrash(self): | |
| self.ScratchFile( | |
| 'MODULE.bazel', | |
| [ | |
| 'module(name = "cycle_test")', | |
| 'cycle_ext = use_extension("//:cycle_def.bzl", "cycle_ext")', | |
| 'use_repo(cycle_ext, "cycle_repo")', | |
| ], | |
| ) | |
| self.ScratchFile( | |
| 'cycle_def.bzl', | |
| [ | |
| 'load("@cycle_repo//:defs.bzl", "dummy")', | |
| 'def _cycle_impl(ctx):', | |
| ' pass', | |
| 'cycle_ext = module_extension(implementation=_cycle_impl)', | |
| ], | |
| ) | |
| self.ScratchFile('BUILD.bazel') | |
| exit_code, _, stderr = self.RunBazel( | |
| ['mod', 'graph'], | |
| rstrip=True, | |
| allow_failure=True, | |
| ) | |
| self.AssertNotExitCode(exit_code, 0, stderr) | |
| stderr_str = '\n'.join(stderr) | |
| self.assertNotIn( | |
| 'FATAL: bazel crashed due to an internal error', stderr_str | |
| ) | |
| self.assertNotIn('UnsupportedOperationException', stderr_str) | |
| self.assertIn('Circular definition of repositories', stderr_str) | |
| if __name__ == '__main__': | |
| absltest.main() |