python/mozbuild/mozbuild/test/configure/test_checks_configure.py

   1 # This Source Code Form is subject to the terms of the Mozilla Public
   2 # License, v. 2.0. If a copy of the MPL was not distributed with this
   3 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   4
   5 import os
   6 import sys
   7 import textwrap
   8 import unittest
   9
  10 from buildconfig import topsrcdir
  11 from mozpack import path as mozpath
  12 from mozunit import MockedOpen, main
  13 from six import StringIO
  14
  15 from common import ConfigureTestSandbox, ensure_exe_extension, fake_short_path
  16 from mozbuild.configure import ConfigureError, ConfigureSandbox
  17 from mozbuild.shellutil import quote as shell_quote
  18
  19
  20 class TestChecksConfigure(unittest.TestCase):
  21     def test_checking(self):
  22         def make_test(to_exec):
  23             def test(val, msg):
  24                 out = StringIO()
  25                 sandbox = ConfigureSandbox({}, stdout=out, stderr=out)
  26                 base_dir = os.path.join(topsrcdir, "build", "moz.configure")
  27                 sandbox.include_file(os.path.join(base_dir, "checks.configure"))
  28                 exec(to_exec, sandbox)
  29                 sandbox["foo"](val)
  30                 self.assertEqual(out.getvalue(), msg)
  31
  32             return test
  33
  34         test = make_test(
  35             textwrap.dedent(
  36                 """
  37             @checking('for a thing')
  38             def foo(value):
  39                 return value
  40         """
  41             )
  42         )
  43         test(True, "checking for a thing... yes\n")
  44         test(False, "checking for a thing... no\n")
  45         test(42, "checking for a thing... 42\n")
  46         test("foo", "checking for a thing... foo\n")
  47         data = ["foo", "bar"]
  48         test(data, "checking for a thing... %r\n" % data)
  49
  50         # When the function given to checking does nothing interesting, the
  51         # behavior is not altered
  52         test = make_test(
  53             textwrap.dedent(
  54                 """
  55             @checking('for a thing', lambda x: x)
  56             def foo(value):
  57                 return value
  58         """
  59             )
  60         )
  61         test(True, "checking for a thing... yes\n")
  62         test(False, "checking for a thing... no\n")
  63         test(42, "checking for a thing... 42\n")
  64         test("foo", "checking for a thing... foo\n")
  65         data = ["foo", "bar"]
  66         test(data, "checking for a thing... %r\n" % data)
  67
  68         test = make_test(
  69             textwrap.dedent(
  70                 """
  71             def munge(x):
  72                 if not x:
  73                     return 'not found'
  74                 if isinstance(x, (str, bool, int)):
  75                     return x
  76                 return ' '.join(x)
  77
  78             @checking('for a thing', munge)
  79             def foo(value):
  80                 return value
  81         """
  82             )
  83         )
  84         test(True, "checking for a thing... yes\n")
  85         test(False, "checking for a thing... not found\n")
  86         test(42, "checking for a thing... 42\n")
  87         test("foo", "checking for a thing... foo\n")
  88         data = ["foo", "bar"]
  89         test(data, "checking for a thing... foo bar\n")
  90
  91     KNOWN_A = ensure_exe_extension(mozpath.abspath("/usr/bin/known-a"))
  92     KNOWN_B = ensure_exe_extension(mozpath.abspath("/usr/local/bin/known-b"))
  93     KNOWN_C = ensure_exe_extension(mozpath.abspath("/home/user/bin/known c"))
  94     OTHER_A = ensure_exe_extension(mozpath.abspath("/lib/other/known-a"))
  95
  96     def get_result(
  97         self,
  98         command="",
  99         args=[],
 100         environ={},
 101         prog="/bin/configure",
 102         extra_paths=None,
 103         includes=("util.configure", "checks.configure"),
 104     ):
 105         config = {}
 106         out = StringIO()
 107         paths = {self.KNOWN_A: None, self.KNOWN_B: None, self.KNOWN_C: None}
 108         if extra_paths:
 109             paths.update(extra_paths)
 110         environ = dict(environ)
 111         if "PATH" not in environ:
 112             environ["PATH"] = os.pathsep.join(os.path.dirname(p) for p in paths)
 113         paths[self.OTHER_A] = None
 114         sandbox = ConfigureTestSandbox(paths, config, environ, [prog] + args, out, out)
 115         base_dir = os.path.join(topsrcdir, "build", "moz.configure")
 116         for f in includes:
 117             sandbox.include_file(os.path.join(base_dir, f))
 118
 119         status = 0
 120         try:
 121             exec(command, sandbox)
 122             sandbox.run()
 123         except SystemExit as e:
 124             status = e.code
 125
 126         return config, out.getvalue(), status
 127
 128     def test_check_prog(self):
 129         config, out, status = self.get_result('check_prog("FOO", ("known-a",))')
 130         self.assertEqual(status, 0)
 131         self.assertEqual(config, {"FOO": self.KNOWN_A})
 132         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 133
 134         config, out, status = self.get_result(
 135             'check_prog("FOO", ("unknown", "known-b", "known c"))'
 136         )
 137         self.assertEqual(status, 0)
 138         self.assertEqual(config, {"FOO": self.KNOWN_B})
 139         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_B)
 140
 141         config, out, status = self.get_result(
 142             'check_prog("FOO", ("unknown", "unknown-2", "known c"))'
 143         )
 144         self.assertEqual(status, 0)
 145         self.assertEqual(config, {"FOO": fake_short_path(self.KNOWN_C)})
 146         self.assertEqual(
 147             out, "checking for foo... %s\n" % shell_quote(fake_short_path(self.KNOWN_C))
 148         )
 149
 150         config, out, status = self.get_result('check_prog("FOO", ("unknown",))')
 151         self.assertEqual(status, 1)
 152         self.assertEqual(config, {})
 153         self.assertEqual(
 154             out,
 155             textwrap.dedent(
 156                 """\
 157             checking for foo... not found
 158             DEBUG: foo: Looking for unknown
 159             ERROR: Cannot find foo
 160         """
 161             ),
 162         )
 163
 164         config, out, status = self.get_result(
 165             'check_prog("FOO", ("unknown", "unknown-2", "unknown 3"))'
 166         )
 167         self.assertEqual(status, 1)
 168         self.assertEqual(config, {})
 169         self.assertEqual(
 170             out,
 171             textwrap.dedent(
 172                 """\
 173             checking for foo... not found
 174             DEBUG: foo: Looking for unknown
 175             DEBUG: foo: Looking for unknown-2
 176             DEBUG: foo: Looking for 'unknown 3'
 177             ERROR: Cannot find foo
 178         """
 179             ),
 180         )
 181
 182         config, out, status = self.get_result(
 183             'check_prog("FOO", ("unknown", "unknown-2", "unknown 3"), '
 184             "allow_missing=True)"
 185         )
 186         self.assertEqual(status, 0)
 187         self.assertEqual(config, {})
 188         self.assertEqual(out, "checking for foo... not found\n")
 189
 190     @unittest.skipIf(not sys.platform.startswith("win"), "Windows-only test")
 191     def test_check_prog_exe(self):
 192         config, out, status = self.get_result(
 193             'check_prog("FOO", ("unknown", "known-b", "known c"))', ["FOO=known-a.exe"]
 194         )
 195         self.assertEqual(status, 0)
 196         self.assertEqual(config, {"FOO": self.KNOWN_A})
 197         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 198
 199         config, out, status = self.get_result(
 200             'check_prog("FOO", ("unknown", "known-b", "known c"))',
 201             ["FOO=%s" % os.path.splitext(self.KNOWN_A)[0]],
 202         )
 203         self.assertEqual(status, 0)
 204         self.assertEqual(config, {"FOO": self.KNOWN_A})
 205         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 206
 207     def test_check_prog_with_args(self):
 208         config, out, status = self.get_result(
 209             'check_prog("FOO", ("unknown", "known-b", "known c"))', ["FOO=known-a"]
 210         )
 211         self.assertEqual(status, 0)
 212         self.assertEqual(config, {"FOO": self.KNOWN_A})
 213         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 214
 215         config, out, status = self.get_result(
 216             'check_prog("FOO", ("unknown", "known-b", "known c"))',
 217             ["FOO=%s" % self.KNOWN_A],
 218         )
 219         self.assertEqual(status, 0)
 220         self.assertEqual(config, {"FOO": self.KNOWN_A})
 221         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 222
 223         path = self.KNOWN_B.replace("known-b", "known-a")
 224         config, out, status = self.get_result(
 225             'check_prog("FOO", ("unknown", "known-b", "known c"))', ["FOO=%s" % path]
 226         )
 227         self.assertEqual(status, 1)
 228         self.assertEqual(config, {})
 229         self.assertEqual(
 230             out,
 231             textwrap.dedent(
 232                 """\
 233             checking for foo... not found
 234             DEBUG: foo: Looking for %s
 235             ERROR: Cannot find foo
 236         """
 237             )
 238             % path,
 239         )
 240
 241         config, out, status = self.get_result(
 242             'check_prog("FOO", ("unknown",))', ["FOO=known c"]
 243         )
 244         self.assertEqual(status, 0)
 245         self.assertEqual(config, {"FOO": fake_short_path(self.KNOWN_C)})
 246         self.assertEqual(
 247             out, "checking for foo... %s\n" % shell_quote(fake_short_path(self.KNOWN_C))
 248         )
 249
 250         config, out, status = self.get_result(
 251             'check_prog("FOO", ("unknown", "unknown-2", "unknown 3"), '
 252             "allow_missing=True)",
 253             ["FOO=unknown"],
 254         )
 255         self.assertEqual(status, 1)
 256         self.assertEqual(config, {})
 257         self.assertEqual(
 258             out,
 259             textwrap.dedent(
 260                 """\
 261             checking for foo... not found
 262             DEBUG: foo: Looking for unknown
 263             ERROR: Cannot find foo
 264         """
 265             ),
 266         )
 267
 268     def test_check_prog_what(self):
 269         config, out, status = self.get_result(
 270             'check_prog("CC", ("known-a",), what="the target C compiler")'
 271         )
 272         self.assertEqual(status, 0)
 273         self.assertEqual(config, {"CC": self.KNOWN_A})
 274         self.assertEqual(
 275             out, "checking for the target C compiler... %s\n" % self.KNOWN_A
 276         )
 277
 278         config, out, status = self.get_result(
 279             'check_prog("CC", ("unknown", "unknown-2", "unknown 3"),'
 280             '           what="the target C compiler")'
 281         )
 282         self.assertEqual(status, 1)
 283         self.assertEqual(config, {})
 284         self.assertEqual(
 285             out,
 286             textwrap.dedent(
 287                 """\
 288             checking for the target C compiler... not found
 289             DEBUG: cc: Looking for unknown
 290             DEBUG: cc: Looking for unknown-2
 291             DEBUG: cc: Looking for 'unknown 3'
 292             ERROR: Cannot find the target C compiler
 293         """
 294             ),
 295         )
 296
 297     def test_check_prog_input(self):
 298         config, out, status = self.get_result(
 299             textwrap.dedent(
 300                 """
 301             option("--with-ccache", nargs=1, help="ccache")
 302             check_prog("CCACHE", ("known-a",), input="--with-ccache")
 303         """
 304             ),
 305             ["--with-ccache=known-b"],
 306         )
 307         self.assertEqual(status, 0)
 308         self.assertEqual(config, {"CCACHE": self.KNOWN_B})
 309         self.assertEqual(out, "checking for ccache... %s\n" % self.KNOWN_B)
 310
 311         script = textwrap.dedent(
 312             """
 313             option(env="CC", nargs=1, help="compiler")
 314             @depends("CC")
 315             def compiler(value):
 316                 return value[0].split()[0] if value else None
 317             check_prog("CC", ("known-a",), input=compiler)
 318         """
 319         )
 320         config, out, status = self.get_result(script)
 321         self.assertEqual(status, 0)
 322         self.assertEqual(config, {"CC": self.KNOWN_A})
 323         self.assertEqual(out, "checking for cc... %s\n" % self.KNOWN_A)
 324
 325         config, out, status = self.get_result(script, ["CC=known-b"])
 326         self.assertEqual(status, 0)
 327         self.assertEqual(config, {"CC": self.KNOWN_B})
 328         self.assertEqual(out, "checking for cc... %s\n" % self.KNOWN_B)
 329
 330         config, out, status = self.get_result(script, ["CC=known-b -m32"])
 331         self.assertEqual(status, 0)
 332         self.assertEqual(config, {"CC": self.KNOWN_B})
 333         self.assertEqual(out, "checking for cc... %s\n" % self.KNOWN_B)
 334
 335     def test_check_prog_progs(self):
 336         config, out, status = self.get_result('check_prog("FOO", ())')
 337         self.assertEqual(status, 0)
 338         self.assertEqual(config, {})
 339         self.assertEqual(out, "")
 340
 341         config, out, status = self.get_result('check_prog("FOO", ())', ["FOO=known-a"])
 342         self.assertEqual(status, 0)
 343         self.assertEqual(config, {"FOO": self.KNOWN_A})
 344         self.assertEqual(out, "checking for foo... %s\n" % self.KNOWN_A)
 345
 346         script = textwrap.dedent(
 347             """
 348             option(env="TARGET", nargs=1, default="linux", help="target")
 349             @depends("TARGET")
 350             def compiler(value):
 351                 if value:
 352                     if value[0] == "linux":
 353                         return ("gcc", "clang")
 354                     if value[0] == "winnt":
 355                         return ("cl", "clang-cl")
 356             check_prog("CC", compiler)
 357         """
 358         )
 359         config, out, status = self.get_result(script)
 360         self.assertEqual(status, 1)
 361         self.assertEqual(config, {})
 362         self.assertEqual(
 363             out,
 364             textwrap.dedent(
 365                 """\
 366             checking for cc... not found
 367             DEBUG: cc: Looking for gcc
 368             DEBUG: cc: Looking for clang
 369             ERROR: Cannot find cc
 370         """
 371             ),
 372         )
 373
 374         config, out, status = self.get_result(script, ["TARGET=linux"])
 375         self.assertEqual(status, 1)
 376         self.assertEqual(config, {})
 377         self.assertEqual(
 378             out,
 379             textwrap.dedent(
 380                 """\
 381             checking for cc... not found
 382             DEBUG: cc: Looking for gcc
 383             DEBUG: cc: Looking for clang
 384             ERROR: Cannot find cc
 385         """
 386             ),
 387         )
 388
 389         config, out, status = self.get_result(script, ["TARGET=winnt"])
 390         self.assertEqual(status, 1)
 391         self.assertEqual(config, {})
 392         self.assertEqual(
 393             out,
 394             textwrap.dedent(
 395                 """\
 396             checking for cc... not found
 397             DEBUG: cc: Looking for cl
 398             DEBUG: cc: Looking for clang-cl
 399             ERROR: Cannot find cc
 400         """
 401             ),
 402         )
 403
 404         config, out, status = self.get_result(script, ["TARGET=none"])
 405         self.assertEqual(status, 0)
 406         self.assertEqual(config, {})
 407         self.assertEqual(out, "")
 408
 409         config, out, status = self.get_result(script, ["TARGET=winnt", "CC=known-a"])
 410         self.assertEqual(status, 0)
 411         self.assertEqual(config, {"CC": self.KNOWN_A})
 412         self.assertEqual(out, "checking for cc... %s\n" % self.KNOWN_A)
 413
 414         config, out, status = self.get_result(script, ["TARGET=none", "CC=known-a"])
 415         self.assertEqual(status, 0)
 416         self.assertEqual(config, {"CC": self.KNOWN_A})
 417         self.assertEqual(out, "checking for cc... %s\n" % self.KNOWN_A)
 418
 419     def test_check_prog_configure_error(self):
 420         with self.assertRaises(ConfigureError) as e:
 421             self.get_result('check_prog("FOO", "foo")')
 422
 423         self.assertEqual(str(e.exception), "progs must resolve to a list or tuple!")
 424
 425         with self.assertRaises(ConfigureError) as e:
 426             self.get_result(
 427                 'foo = depends(when=True)(lambda: ("a", "b"))\n'
 428                 'check_prog("FOO", ("known-a",), input=foo)'
 429             )
 430
 431         self.assertEqual(
 432             str(e.exception),
 433             "input must resolve to a tuple or a list with a "
 434             "single element, or a string",
 435         )
 436
 437         with self.assertRaises(ConfigureError) as e:
 438             self.get_result(
 439                 'foo = depends(when=True)(lambda: {"a": "b"})\n'
 440                 'check_prog("FOO", ("known-a",), input=foo)'
 441             )
 442
 443         self.assertEqual(
 444             str(e.exception),
 445             "input must resolve to a tuple or a list with a "
 446             "single element, or a string",
 447         )
 448
 449     def test_check_prog_with_path(self):
 450         config, out, status = self.get_result(
 451             'check_prog("A", ("known-a",), paths=["/some/path"])'
 452         )
 453         self.assertEqual(status, 1)
 454         self.assertEqual(config, {})
 455         self.assertEqual(
 456             out,
 457             textwrap.dedent(
 458                 """\
 459             checking for a... not found
 460             DEBUG: a: Looking for known-a
 461             ERROR: Cannot find a
 462         """
 463             ),
 464         )
 465
 466         config, out, status = self.get_result(
 467             'check_prog("A", ("known-a",), paths=["%s"])'
 468             % os.path.dirname(self.OTHER_A)
 469         )
 470         self.assertEqual(status, 0)
 471         self.assertEqual(config, {"A": self.OTHER_A})
 472         self.assertEqual(
 473             out,
 474             textwrap.dedent(
 475                 """\
 476             checking for a... %s
 477         """
 478                 % self.OTHER_A
 479             ),
 480         )
 481
 482         dirs = map(mozpath.dirname, (self.OTHER_A, self.KNOWN_A))
 483         config, out, status = self.get_result(
 484             textwrap.dedent(
 485                 """\
 486             check_prog("A", ("known-a",), paths=["%s"])
 487         """
 488                 % os.pathsep.join(dirs)
 489             )
 490         )
 491         self.assertEqual(status, 0)
 492         self.assertEqual(config, {"A": self.OTHER_A})
 493         self.assertEqual(
 494             out,
 495             textwrap.dedent(
 496                 """\
 497             checking for a... %s
 498         """
 499                 % self.OTHER_A
 500             ),
 501         )
 502
 503         dirs = map(mozpath.dirname, (self.KNOWN_A, self.KNOWN_B))
 504         config, out, status = self.get_result(
 505             textwrap.dedent(
 506                 """\
 507             check_prog("A", ("known-a",), paths=["%s", "%s"])
 508         """
 509                 % (os.pathsep.join(dirs), self.OTHER_A)
 510             )
 511         )
 512         self.assertEqual(status, 0)
 513         self.assertEqual(config, {"A": self.KNOWN_A})
 514         self.assertEqual(
 515             out,
 516             textwrap.dedent(
 517                 """\
 518             checking for a... %s
 519         """
 520                 % self.KNOWN_A
 521             ),
 522         )
 523
 524         config, out, status = self.get_result(
 525             'check_prog("A", ("known-a",), paths="%s")' % os.path.dirname(self.OTHER_A)
 526         )
 527
 528         self.assertEqual(status, 1)
 529         self.assertEqual(config, {})
 530         self.assertEqual(
 531             out,
 532             textwrap.dedent(
 533                 """\
 534             checking for a... """  # noqa  # trailing whitespace...
 535                 """
 536             DEBUG: a: Looking for known-a
 537             ERROR: Paths provided to find_program must be a list of strings, not %r
 538         """
 539                 % mozpath.dirname(self.OTHER_A)
 540             ),
 541         )
 542
 543     @unittest.skipIf(
 544         not sys.platform.startswith("linux"),
 545         "Linux-only test, assumes Java is located from a $PATH",
 546     )
 547     def test_java_tool_checks_linux(self):
 548         def run_configure_java(
 549             mock_fs_paths, mock_java_home=None, mock_path=None, args=[]
 550         ):
 551             script = textwrap.dedent(
 552                 """\
 553                     @depends('--help')
 554                     def host(_):
 555                         return namespace(os='unknown', kernel='unknown')
 556                     toolchains_base_dir = depends(when=True)(lambda: '/mozbuild')
 557                     include('%(topsrcdir)s/build/moz.configure/java.configure')
 558                 """
 559                 % {"topsrcdir": topsrcdir}
 560             )
 561
 562             # Don't let system JAVA_HOME influence the test
 563             original_java_home = os.environ.pop("JAVA_HOME", None)
 564             configure_environ = {}
 565
 566             if mock_java_home:
 567                 os.environ["JAVA_HOME"] = mock_java_home
 568                 configure_environ["JAVA_HOME"] = mock_java_home
 569
 570             if mock_path:
 571                 configure_environ["PATH"] = mock_path
 572
 573             # * Even if the real file sysphabtem has a symlink at the mocked path, don't let
 574             #   realpath follow it, as it may influence the test.
 575             # * When finding a binary, check the mock paths rather than the real filesystem.
 576             # Note: Python doesn't allow the different "with" bits to be put in parenthesis,
 577             # because then it thinks it's an un-with-able tuple. Additionally, if this is cleanly
 578             # lined up with "\", black removes them and autoformats them to the block that is
 579             # below.
 580             result = self.get_result(
 581                 args=args,
 582                 command=script,
 583                 extra_paths=paths,
 584                 environ=configure_environ,
 585             )
 586
 587             if original_java_home:
 588                 os.environ["JAVA_HOME"] = original_java_home
 589             return result
 590
 591         java = mozpath.abspath("/usr/bin/java")
 592         javac = mozpath.abspath("/usr/bin/javac")
 593         paths = {java: None, javac: None}
 594         expected_error_message = (
 595             "ERROR: Could not locate Java at /mozbuild/jdk/jdk-17.0.10+7/bin, "
 596             "please run ./mach bootstrap --no-system-changes\n"
 597         )
 598
 599         config, out, status = run_configure_java(paths)
 600         self.assertEqual(status, 1)
 601         self.assertEqual(config, {})
 602         self.assertEqual(out, expected_error_message)
 603
 604         # An alternative valid set of tools referred to by JAVA_HOME.
 605         alt_java = mozpath.abspath("/usr/local/bin/java")
 606         alt_javac = mozpath.abspath("/usr/local/bin/javac")
 607         alt_java_home = mozpath.dirname(mozpath.dirname(alt_java))
 608         paths = {alt_java: None, alt_javac: None, java: None, javac: None}
 609
 610         alt_path = mozpath.dirname(java)
 611         config, out, status = run_configure_java(paths, alt_java_home, alt_path)
 612         self.assertEqual(status, 1)
 613         self.assertEqual(config, {})
 614         self.assertEqual(out, expected_error_message)
 615
 616         # We can use --with-java-bin-path instead of JAVA_HOME to similar
 617         # effect.
 618         config, out, status = run_configure_java(
 619             paths,
 620             mock_path=mozpath.dirname(java),
 621             args=["--with-java-bin-path=%s" % mozpath.dirname(alt_java)],
 622         )
 623         self.assertEqual(status, 0)
 624         self.assertEqual(config, {"JAVA": alt_java, "MOZ_JAVA_CODE_COVERAGE": False})
 625         self.assertEqual(
 626             out,
 627             textwrap.dedent(
 628                 """\
 629              checking for java... %s
 630         """
 631                 % alt_java
 632             ),
 633         )
 634
 635         # If --with-java-bin-path and JAVA_HOME are both set,
 636         # --with-java-bin-path takes precedence.
 637         config, out, status = run_configure_java(
 638             paths,
 639             mock_java_home=mozpath.dirname(mozpath.dirname(java)),
 640             mock_path=mozpath.dirname(java),
 641             args=["--with-java-bin-path=%s" % mozpath.dirname(alt_java)],
 642         )
 643         self.assertEqual(status, 0)
 644         self.assertEqual(config, {"JAVA": alt_java, "MOZ_JAVA_CODE_COVERAGE": False})
 645         self.assertEqual(
 646             out,
 647             textwrap.dedent(
 648                 """\
 649              checking for java... %s
 650         """
 651                 % alt_java
 652             ),
 653         )
 654
 655         # --enable-java-coverage should set MOZ_JAVA_CODE_COVERAGE.
 656         alt_java_home = mozpath.dirname(mozpath.dirname(java))
 657         config, out, status = run_configure_java(
 658             paths,
 659             mock_java_home=alt_java_home,
 660             mock_path=mozpath.dirname(java),
 661             args=["--enable-java-coverage"],
 662         )
 663         self.assertEqual(status, 1)
 664         self.assertEqual(config, {})
 665
 666         # Any missing tool is fatal when these checks run.
 667         paths = {}
 668         config, out, status = run_configure_java(
 669             mock_fs_paths={},
 670             mock_path=mozpath.dirname(java),
 671             args=["--enable-java-coverage"],
 672         )
 673         self.assertEqual(status, 1)
 674         self.assertEqual(config, {})
 675         self.assertEqual(out, expected_error_message)
 676
 677     def test_pkg_check_modules(self):
 678         mock_pkg_config_version = "0.10.0"
 679         mock_pkg_config_path = mozpath.abspath("/usr/bin/pkg-config")
 680
 681         seen_flags = set()
 682
 683         def mock_pkg_config(_, args):
 684             if "--dont-define-prefix" in args:
 685                 args = list(args)
 686                 seen_flags.add(args.pop(args.index("--dont-define-prefix")))
 687                 args = tuple(args)
 688             if args[0:2] == ("--errors-to-stdout", "--print-errors"):
 689                 assert len(args) == 3
 690                 package = args[2]
 691                 if package == "unknown":
 692                     return (
 693                         1,
 694                         "Package unknown was not found in the pkg-config search path.\n"
 695                         "Perhaps you should add the directory containing `unknown.pc'\n"
 696                         "to the PKG_CONFIG_PATH environment variable\n"
 697                         "No package 'unknown' found",
 698                         "",
 699                     )
 700                 if package == "valid":
 701                     return 0, "", ""
 702                 if package == "new > 1.1":
 703                     return 1, "Requested 'new > 1.1' but version of new is 1.1", ""
 704             if args[0] == "--cflags":
 705                 assert len(args) == 2
 706                 return 0, "-I/usr/include/%s" % args[1], ""
 707             if args[0] == "--libs":
 708                 assert len(args) == 2
 709                 return 0, "-l%s" % args[1], ""
 710             if args[0] == "--version":
 711                 return 0, mock_pkg_config_version, ""
 712             if args[0] == "--about":
 713                 return 1, "Unknown option --about", ""
 714             self.fail("Unexpected arguments to mock_pkg_config: %s" % (args,))
 715
 716         def mock_pkgconf(_, args):
 717             if args[0] == "--shared":
 718                 seen_flags.add(args[0])
 719                 args = args[1:]
 720             if args[0] == "--about":
 721                 return 0, "pkgconf {}".format(mock_pkg_config_version), ""
 722             return mock_pkg_config(_, args)
 723
 724         def get_result(cmd, args=[], bootstrapped_sysroot=False, extra_paths=None):
 725             return self.get_result(
 726                 textwrap.dedent(
 727                     """\
 728                 option('--disable-compile-environment', help='compile env')
 729                 compile_environment = depends(when='--enable-compile-environment')(lambda: True)
 730                 toolchain_prefix = depends(when=True)(lambda: None)
 731                 target_multiarch_dir = depends(when=True)(lambda: None)
 732                 target_sysroot = depends(when=True)(lambda: %(sysroot)s)
 733                 target = depends(when=True)(lambda: None)
 734                 include('%(topsrcdir)s/build/moz.configure/util.configure')
 735                 include('%(topsrcdir)s/build/moz.configure/checks.configure')
 736                 # Skip bootstrapping.
 737                 @template
 738                 def check_prog(*args, **kwargs):
 739                     del kwargs["bootstrap"]
 740                     return check_prog(*args, **kwargs)
 741                 include('%(topsrcdir)s/build/moz.configure/pkg.configure')
 742             """
 743                     % {
 744                         "topsrcdir": topsrcdir,
 745                         "sysroot": "namespace(bootstrapped=True)"
 746                         if bootstrapped_sysroot
 747                         else "None",
 748                     }
 749                 )
 750                 + cmd,
 751                 args=args,
 752                 extra_paths=extra_paths,
 753                 includes=(),
 754             )
 755
 756         extra_paths = {mock_pkg_config_path: mock_pkg_config}
 757
 758         config, output, status = get_result("pkg_check_modules('MOZ_VALID', 'valid')")
 759         self.assertEqual(status, 1)
 760         self.assertEqual(
 761             output,
 762             textwrap.dedent(
 763                 """\
 764             checking for pkg_config... not found
 765             ERROR: *** The pkg-config script could not be found. Make sure it is
 766             *** in your path, or set the PKG_CONFIG environment variable
 767             *** to the full path to pkg-config.
 768         """
 769             ),
 770         )
 771
 772         for pkg_config, version, bootstrapped_sysroot, is_pkgconf in (
 773             (mock_pkg_config, "0.10.0", False, False),
 774             (mock_pkg_config, "0.30.0", False, False),
 775             (mock_pkg_config, "0.30.0", True, False),
 776             (mock_pkgconf, "1.1.0", True, True),
 777             (mock_pkgconf, "1.6.0", False, True),
 778             (mock_pkgconf, "1.8.0", False, True),
 779             (mock_pkgconf, "1.8.0", True, True),
 780         ):
 781             seen_flags = set()
 782             mock_pkg_config_version = version
 783             config, output, status = get_result(
 784                 "pkg_check_modules('MOZ_VALID', 'valid')",
 785                 bootstrapped_sysroot=bootstrapped_sysroot,
 786                 extra_paths={mock_pkg_config_path: pkg_config},
 787             )
 788             self.assertEqual(status, 0)
 789             self.assertEqual(
 790                 output,
 791                 textwrap.dedent(
 792                     """\
 793                 checking for pkg_config... %s
 794                 checking for pkg-config version... %s
 795                 checking whether pkg-config is pkgconf... %s
 796                 checking for valid... yes
 797                 checking MOZ_VALID_CFLAGS... -I/usr/include/valid
 798                 checking MOZ_VALID_LIBS... -lvalid
 799             """
 800                     % (
 801                         mock_pkg_config_path,
 802                         mock_pkg_config_version,
 803                         "yes" if is_pkgconf else "no",
 804                     )
 805                 ),
 806             )
 807             self.assertEqual(
 808                 config,
 809                 {
 810                     "PKG_CONFIG": mock_pkg_config_path,
 811                     "MOZ_VALID_CFLAGS": ("-I/usr/include/valid",),
 812                     "MOZ_VALID_LIBS": ("-lvalid",),
 813                 },
 814             )
 815             if version == "1.8.0" and bootstrapped_sysroot:
 816                 self.assertEqual(seen_flags, set(["--shared", "--dont-define-prefix"]))
 817             elif version == "1.8.0":
 818                 self.assertEqual(seen_flags, set(["--shared"]))
 819             elif version in ("1.6.0", "0.30.0") and bootstrapped_sysroot:
 820                 self.assertEqual(seen_flags, set(["--dont-define-prefix"]))
 821             else:
 822                 self.assertEqual(seen_flags, set())
 823
 824         config, output, status = get_result(
 825             "pkg_check_modules('MOZ_UKNOWN', 'unknown')", extra_paths=extra_paths
 826         )
 827         self.assertEqual(status, 1)
 828         self.assertEqual(
 829             output,
 830             textwrap.dedent(
 831                 """\
 832             checking for pkg_config... %s
 833             checking for pkg-config version... %s
 834             checking whether pkg-config is pkgconf... no
 835             checking for unknown... no
 836             ERROR: Package unknown was not found in the pkg-config search path.
 837             ERROR: Perhaps you should add the directory containing `unknown.pc'
 838             ERROR: to the PKG_CONFIG_PATH environment variable
 839             ERROR: No package 'unknown' found
 840         """
 841                 % (mock_pkg_config_path, mock_pkg_config_version)
 842             ),
 843         )
 844         self.assertEqual(config, {"PKG_CONFIG": mock_pkg_config_path})
 845
 846         config, output, status = get_result(
 847             "pkg_check_modules('MOZ_NEW', 'new > 1.1')", extra_paths=extra_paths
 848         )
 849         self.assertEqual(status, 1)
 850         self.assertEqual(
 851             output,
 852             textwrap.dedent(
 853                 """\
 854             checking for pkg_config... %s
 855             checking for pkg-config version... %s
 856             checking whether pkg-config is pkgconf... no
 857             checking for new > 1.1... no
 858             ERROR: Requested 'new > 1.1' but version of new is 1.1
 859         """
 860                 % (mock_pkg_config_path, mock_pkg_config_version)
 861             ),
 862         )
 863         self.assertEqual(config, {"PKG_CONFIG": mock_pkg_config_path})
 864
 865         # allow_missing makes missing packages non-fatal.
 866         cmd = textwrap.dedent(
 867             """\
 868         have_new_module = pkg_check_modules('MOZ_NEW', 'new > 1.1', allow_missing=True)
 869         @depends(have_new_module)
 870         def log_new_module_error(mod):
 871             if mod is not True:
 872                 log.info('Module not found.')
 873         """
 874         )
 875
 876         config, output, status = get_result(cmd, extra_paths=extra_paths)
 877         self.assertEqual(status, 0)
 878         self.assertEqual(
 879             output,
 880             textwrap.dedent(
 881                 """\
 882             checking for pkg_config... %s
 883             checking for pkg-config version... %s
 884             checking whether pkg-config is pkgconf... no
 885             checking for new > 1.1... no
 886             WARNING: Requested 'new > 1.1' but version of new is 1.1
 887             Module not found.
 888         """
 889                 % (mock_pkg_config_path, mock_pkg_config_version)
 890             ),
 891         )
 892         self.assertEqual(config, {"PKG_CONFIG": mock_pkg_config_path})
 893
 894         config, output, status = get_result(
 895             cmd, args=["--disable-compile-environment"], extra_paths=extra_paths
 896         )
 897         self.assertEqual(status, 0)
 898         self.assertEqual(output, "Module not found.\n")
 899         self.assertEqual(config, {})
 900
 901         def mock_old_pkg_config(_, args):
 902             if args[0] == "--version":
 903                 return 0, "0.8.10", ""
 904             if args[0] == "--about":
 905                 return 1, "Unknown option --about", ""
 906             self.fail("Unexpected arguments to mock_old_pkg_config: %s" % args)
 907
 908         extra_paths = {mock_pkg_config_path: mock_old_pkg_config}
 909
 910         config, output, status = get_result(
 911             "pkg_check_modules('MOZ_VALID', 'valid')", extra_paths=extra_paths
 912         )
 913         self.assertEqual(status, 1)
 914         self.assertEqual(
 915             output,
 916             textwrap.dedent(
 917                 """\
 918             checking for pkg_config... %s
 919             checking for pkg-config version... 0.8.10
 920             checking whether pkg-config is pkgconf... no
 921             ERROR: *** Your version of pkg-config is too old. You need version 0.9.0 or newer.
 922         """
 923                 % mock_pkg_config_path
 924             ),
 925         )
 926
 927     def test_simple_keyfile(self):
 928         includes = ("util.configure", "checks.configure", "keyfiles.configure")
 929
 930         config, output, status = self.get_result(
 931             "simple_keyfile('Mozilla API')", includes=includes
 932         )
 933         self.assertEqual(status, 0)
 934         self.assertEqual(
 935             output,
 936             textwrap.dedent(
 937                 """\
 938             checking for the Mozilla API key... no
 939         """
 940             ),
 941         )
 942         self.assertEqual(config, {"MOZ_MOZILLA_API_KEY": "no-mozilla-api-key"})
 943
 944         config, output, status = self.get_result(
 945             "simple_keyfile('Mozilla API')",
 946             args=["--with-mozilla-api-keyfile=/foo/bar/does/not/exist"],
 947             includes=includes,
 948         )
 949         self.assertEqual(status, 1)
 950         self.assertEqual(
 951             output,
 952             textwrap.dedent(
 953                 """\
 954             checking for the Mozilla API key... no
 955             ERROR: '/foo/bar/does/not/exist': No such file or directory.
 956         """
 957             ),
 958         )
 959         self.assertEqual(config, {})
 960
 961         with MockedOpen({"key": ""}):
 962             config, output, status = self.get_result(
 963                 "simple_keyfile('Mozilla API')",
 964                 args=["--with-mozilla-api-keyfile=key"],
 965                 includes=includes,
 966             )
 967             self.assertEqual(status, 1)
 968             self.assertEqual(
 969                 output,
 970                 textwrap.dedent(
 971                     """\
 972                 checking for the Mozilla API key... no
 973                 ERROR: 'key' is empty.
 974             """
 975                 ),
 976             )
 977             self.assertEqual(config, {})
 978
 979         with MockedOpen({"key": "fake-key\n"}):
 980             config, output, status = self.get_result(
 981                 "simple_keyfile('Mozilla API')",
 982                 args=["--with-mozilla-api-keyfile=key"],
 983                 includes=includes,
 984             )
 985             self.assertEqual(status, 0)
 986             self.assertEqual(
 987                 output,
 988                 textwrap.dedent(
 989                     """\
 990                 checking for the Mozilla API key... yes
 991             """
 992                 ),
 993             )
 994             self.assertEqual(config, {"MOZ_MOZILLA_API_KEY": "fake-key"})
 995
 996         with MockedOpen({"default": "default-key\n"}):
 997             config, output, status = self.get_result(
 998                 "simple_keyfile('Mozilla API', default='default')", includes=includes
 999             )
1000             self.assertEqual(status, 0)
1001             self.assertEqual(
1002                 output,
1003                 textwrap.dedent(
1004                     """\
1005                 checking for the Mozilla API key... yes
1006             """
1007                 ),
1008             )
1009             self.assertEqual(config, {"MOZ_MOZILLA_API_KEY": "default-key"})
1010
1011         with MockedOpen({"default": "default-key\n", "key": "fake-key\n"}):
1012             config, output, status = self.get_result(
1013                 "simple_keyfile('Mozilla API', default='key')", includes=includes
1014             )
1015             self.assertEqual(status, 0)
1016             self.assertEqual(
1017                 output,
1018                 textwrap.dedent(
1019                     """\
1020                 checking for the Mozilla API key... yes
1021             """
1022                 ),
1023             )
1024             self.assertEqual(config, {"MOZ_MOZILLA_API_KEY": "fake-key"})
1025
1026     def test_id_and_secret_keyfile(self):
1027         includes = ("util.configure", "checks.configure", "keyfiles.configure")
1028
1029         config, output, status = self.get_result(
1030             "id_and_secret_keyfile('Bing API')", includes=includes
1031         )
1032         self.assertEqual(status, 0)
1033         self.assertEqual(
1034             output,
1035             textwrap.dedent(
1036                 """\
1037             checking for the Bing API key... no
1038         """
1039             ),
1040         )
1041         self.assertEqual(
1042             config,
1043             {
1044                 "MOZ_BING_API_CLIENTID": "no-bing-api-clientid",
1045                 "MOZ_BING_API_KEY": "no-bing-api-key",
1046             },
1047         )
1048
1049         config, output, status = self.get_result(
1050             "id_and_secret_keyfile('Bing API')",
1051             args=["--with-bing-api-keyfile=/foo/bar/does/not/exist"],
1052             includes=includes,
1053         )
1054         self.assertEqual(status, 1)
1055         self.assertEqual(
1056             output,
1057             textwrap.dedent(
1058                 """\
1059             checking for the Bing API key... no
1060             ERROR: '/foo/bar/does/not/exist': No such file or directory.
1061         """
1062             ),
1063         )
1064         self.assertEqual(config, {})
1065
1066         with MockedOpen({"key": ""}):
1067             config, output, status = self.get_result(
1068                 "id_and_secret_keyfile('Bing API')",
1069                 args=["--with-bing-api-keyfile=key"],
1070                 includes=includes,
1071             )
1072             self.assertEqual(status, 1)
1073             self.assertEqual(
1074                 output,
1075                 textwrap.dedent(
1076                     """\
1077                 checking for the Bing API key... no
1078                 ERROR: 'key' is empty.
1079             """
1080                 ),
1081             )
1082             self.assertEqual(config, {})
1083
1084         with MockedOpen({"key": "fake-id fake-key\n"}):
1085             config, output, status = self.get_result(
1086                 "id_and_secret_keyfile('Bing API')",
1087                 args=["--with-bing-api-keyfile=key"],
1088                 includes=includes,
1089             )
1090             self.assertEqual(status, 0)
1091             self.assertEqual(
1092                 output,
1093                 textwrap.dedent(
1094                     """\
1095                 checking for the Bing API key... yes
1096             """
1097                 ),
1098             )
1099             self.assertEqual(
1100                 config,
1101                 {"MOZ_BING_API_CLIENTID": "fake-id", "MOZ_BING_API_KEY": "fake-key"},
1102             )
1103
1104         with MockedOpen({"key": "fake-key\n"}):
1105             config, output, status = self.get_result(
1106                 "id_and_secret_keyfile('Bing API')",
1107                 args=["--with-bing-api-keyfile=key"],
1108                 includes=includes,
1109             )
1110             self.assertEqual(status, 1)
1111             self.assertEqual(
1112                 output,
1113                 textwrap.dedent(
1114                     """\
1115                 checking for the Bing API key... no
1116                 ERROR: Bing API key file has an invalid format.
1117             """
1118                 ),
1119             )
1120             self.assertEqual(config, {})
1121
1122         with MockedOpen({"default-key": "default-id default-key\n"}):
1123             config, output, status = self.get_result(
1124                 "id_and_secret_keyfile('Bing API', default='default-key')",
1125                 includes=includes,
1126             )
1127             self.assertEqual(status, 0)
1128             self.assertEqual(
1129                 output,
1130                 textwrap.dedent(
1131                     """\
1132                 checking for the Bing API key... yes
1133             """
1134                 ),
1135             )
1136             self.assertEqual(
1137                 config,
1138                 {
1139                     "MOZ_BING_API_CLIENTID": "default-id",
1140                     "MOZ_BING_API_KEY": "default-key",
1141                 },
1142             )
1143
1144         with MockedOpen(
1145             {"default-key": "default-id default-key\n", "key": "fake-id fake-key\n"}
1146         ):
1147             config, output, status = self.get_result(
1148                 "id_and_secret_keyfile('Bing API', default='default-key')",
1149                 args=["--with-bing-api-keyfile=key"],
1150                 includes=includes,
1151             )
1152             self.assertEqual(status, 0)
1153             self.assertEqual(
1154                 output,
1155                 textwrap.dedent(
1156                     """\
1157                 checking for the Bing API key... yes
1158             """
1159                 ),
1160             )
1161             self.assertEqual(
1162                 config,
1163                 {"MOZ_BING_API_CLIENTID": "fake-id", "MOZ_BING_API_KEY": "fake-key"},
1164             )
1165
1166
1167 if __name__ == "__main__":
1168     main()