From 3fb91a27d839bbb990597669acbf9344a2607a5d Mon Sep 17 00:00:00 2001 From: jnasbyupgrade Date: Sat, 1 Aug 2026 16:47:38 -0500 Subject: [PATCH 1/5] Add coverage for PGXNTOOL_ENABLE_FS_INSTALL / PGXNTOOL_ENABLE_PGXN_INSTALL Add tests/updates for pgxntool commit 6966d3c (adds PGXNTOOL_ENABLE_FS_INSTALL / PGXNTOOL_ENABLE_PGXN_INSTALL): - `install` is now conditionally gated out of `test`/`verify-results`/ `installcheck`/`test-build` via `PGXNTOOL_ENABLE_FS_INSTALL`, for existing-mode/pg_tle-style testing (issues #55, #90) - pgtap's own `pgxn install --sudo` auto-install is independently gated via `PGXNTOOL_ENABLE_PGXN_INSTALL`, defaulting to follow `PGXNTOOL_ENABLE_FS_INSTALL` Extends `test/standard/make-test.bats` with: default/override/independent- override behavior (via `print-%`); structural proof via `make -p -n` that `install`/`pgtap` prerequisites are genuinely removed from `installcheck`'s parsed rule, not just skipped at runtime; a dry-run proof (via a fake `DESTDIR`) that the `pgxn install pgtap --sudo` recipe disappears when disabled; and end-to-end proof that `make test PGXNTOOL_ENABLE_FS_INSTALL=no` succeeds against an already-installed tree but fails against a genuinely uninstalled one. Also tightens two `installcheck` prerequisite-list assertions (the pre-existing issue #79 one and the new one) to match the exact `install` token instead of a `grep -w` substring, which false-matched inside the unrelated `test/install/schedule` path. Co-Authored-By: Claude --- test/standard/make-test.bats | 140 ++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) diff --git a/test/standard/make-test.bats b/test/standard/make-test.bats index 4b93eb5..64b7958 100755 --- a/test/standard/make-test.bats +++ b/test/standard/make-test.bats @@ -11,6 +11,10 @@ # - unique per-directory database naming (REGRESS_DBNAME) # - installcheck always runs after install, even when pulled in indirectly # (issue #79) +# - PGXNTOOL_ENABLE_FS_INSTALL can disable the install prerequisite entirely, +# for "existing mode"/pg_tle-style testing (issues #55, #90) +# - PGXNTOOL_ENABLE_PGXN_INSTALL can independently disable the pgtap +# dependency's own `pgxn install --sudo` auto-install # - check-stale-expected catches orphaned test/expected/*.out files (issue #14) # - `make test` exits non-zero on a real regression.diffs mismatch (issue #49) # - verify-results blocks `make results` when tests are failing, detects @@ -170,7 +174,10 @@ EOF prereq_line=$(echo "$output" | awk '/^installcheck:/{print; exit}') [ -n "$prereq_line" ] || error "installcheck rule not found in 'make -p' database dump" - echo "$prereq_line" | grep -qw install || \ + # Split on whitespace and match the exact "install" token -- grep -w alone + # would also match inside "test/install/schedule" (PGXNTOOL_ENABLE_TEST_INSTALL's + # generated schedule file path), which is word-bounded by slashes too. + echo "$prereq_line" | tr ' ' '\n' | grep -qx install || \ error "installcheck's parsed prerequisite list does not include 'install': $prereq_line" } @@ -193,6 +200,137 @@ EOF assert_not_contains "$output" "does not exist" } +# ============================================================================ +# install/installcheck can skip filesystem install (issues #55, #90) +# ============================================================================ +# +# `test`/`verify-results` always filesystem-installed the extension via +# PGXS's `install`, and `installcheck` always depended on `install` (the +# issue #79 fix, tested above) -- with no way to disable either. That defeats +# "existing mode" testing, where the extension under test was deployed some +# other way (e.g. a pg_tle registration, or a real pg_upgrade) and the whole +# point is to prove that other deployment path works -- filesystem-installing +# as a side effect defeats it. PGXNTOOL_ENABLE_FS_INSTALL=no removes both the +# TEST_DEPS `install` entry and the `installcheck: install` edge. + +@test "PGXNTOOL_ENABLE_FS_INSTALL=no removes install from installcheck's parsed prerequisite list" { + # Same structural technique as the issue #79 test above, inverted: prove + # the edge is genuinely gone, not just that a real run happened to succeed + # regardless of scheduling order. + run make -p -n installcheck PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success + + local prereq_line + prereq_line=$(echo "$output" | awk '/^installcheck:/{print; exit}') + [ -n "$prereq_line" ] || error "installcheck rule not found in 'make -p' database dump" + + # Split on whitespace and match the exact "install" token -- grep -w would + # false-positive on the unrelated "test/install/schedule" path (PGXNTOOL_ENABLE_TEST_INSTALL's + # generated schedule file), which is also a word-bounded "install" once + # surrounded by slashes. + if echo "$prereq_line" | tr ' ' '\n' | grep -qx install; then + error "installcheck's parsed prerequisite list still includes 'install' with PGXNTOOL_ENABLE_FS_INSTALL=no: $prereq_line" + fi +} + +@test "PGXNTOOL_ENABLE_FS_INSTALL=no removes install's recipe from make test's dry run" { + run make -n test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success + assert_not_contains "$output" "install -c -m 644" +} + +@test "PGXNTOOL_ENABLE_FS_INSTALL rejects invalid values" { + run make print-PGXNTOOL_ENABLE_FS_INSTALL PGXNTOOL_ENABLE_FS_INSTALL=bogus + assert_failure + assert_contains "$output" "PGXNTOOL_ENABLE_FS_INSTALL must be" +} + +@test "make test succeeds with PGXNTOOL_ENABLE_FS_INSTALL=no when the extension is already installed" { + skip_if_no_postgres + + # Stands in for "existing mode": the extension is already deployed (here, + # via a normal install) before test/installcheck ever runs, so disabling + # the FS install prerequisite shouldn't stop the suite from passing. + run make install + assert_success + + run make test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success +} + +@test "make test fails with PGXNTOOL_ENABLE_FS_INSTALL=no against a genuinely uninstalled tree" { + skip_if_no_postgres + + # Inverse of the issue #79 test above: with filesystem install disabled, + # pg_regress must run against whatever's already there -- on a genuinely + # uninstalled tree that means failure, which is the real-world proof that + # `install` genuinely didn't run as a side effect (the structural test + # above already proves the edge itself is gone; this proves it matters). + run make uninstall + assert_success + + run make test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_failure + assert_contains "$output" "does not exist" + + # Restore installed state for the rest of this file's tests. + run make install + assert_success +} + +# ---------------------------------------------------------------------------- +# pgtap auto-install can be disabled independently (PGXNTOOL_ENABLE_PGXN_INSTALL) +# ---------------------------------------------------------------------------- +# +# `installcheck` also auto-installs the pgtap dependency via `pgxn install +# pgtap --sudo` when it isn't already filesystem-installed -- itself a +# filesystem-install side effect, and the same problem +# PGXNTOOL_ENABLE_FS_INSTALL solves for the extension under test. +# PGXNTOOL_ENABLE_PGXN_INSTALL defaults to following PGXNTOOL_ENABLE_FS_INSTALL, +# but can be set independently. + +@test "PGXNTOOL_ENABLE_PGXN_INSTALL defaults to following PGXNTOOL_ENABLE_FS_INSTALL" { + run make print-PGXNTOOL_ENABLE_PGXN_INSTALL + assert_success + assert_contains "$output" 'set to "yes"' + + run make print-PGXNTOOL_ENABLE_PGXN_INSTALL PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success + assert_contains "$output" 'set to "no"' +} + +@test "PGXNTOOL_ENABLE_PGXN_INSTALL can be set independently of PGXNTOOL_ENABLE_FS_INSTALL" { + run make print-PGXNTOOL_ENABLE_PGXN_INSTALL PGXNTOOL_ENABLE_FS_INSTALL=no PGXNTOOL_ENABLE_PGXN_INSTALL=yes + assert_success + assert_contains "$output" 'set to "yes"' +} + +@test "PGXNTOOL_ENABLE_PGXN_INSTALL=no removes pgtap's recipe from a dry-run installcheck" { + # pgtap's file-check target ($(DESTDIR)$(datadir)/extension/pgtap.control) + # is already satisfied on this machine (pgtap is genuinely installed), so + # a plain dry-run never shows the "pgxn install" recipe regardless of this + # variable -- it wouldn't prove anything either way. Pointing DESTDIR at a + # nonexistent path makes that file-check target genuinely unsatisfied, + # forcing the recipe to appear in a *dry* run (nothing is actually + # installed there -- -n never executes it) -- that's what actually proves + # PGXNTOOL_ENABLE_PGXN_INSTALL gates it. + local fake_destdir="$BATS_TEST_TMPDIR/fake-destdir" + + run make -n installcheck "DESTDIR=$fake_destdir" + assert_success + assert_contains "$output" "pgxn install pgtap --sudo" + + run make -n installcheck "DESTDIR=$fake_destdir" PGXNTOOL_ENABLE_PGXN_INSTALL=no + assert_success + assert_not_contains "$output" "pgxn install pgtap --sudo" +} + +@test "PGXNTOOL_ENABLE_PGXN_INSTALL rejects invalid values" { + run make print-PGXNTOOL_ENABLE_PGXN_INSTALL PGXNTOOL_ENABLE_PGXN_INSTALL=bogus + assert_failure + assert_contains "$output" "PGXNTOOL_ENABLE_PGXN_INSTALL must be" +} + # Test: check-stale-expected (issue #14) # # `make test` never caught a stale test/expected/*.out left behind after a From 3dcc14a02775919c35ff8377dace51da06513ced Mon Sep 17 00:00:00 2001 From: jnasbyupgrade Date: Tue, 8 Sep 2026 16:15:56 -0500 Subject: [PATCH 2/5] Address PR #70 review: dry-run clarity, reduce install-state churn Add a comment explaining why the install-recipe dry-run test needs no DESTDIR faking (install's own target has no file to gate on, unlike pgtap's), and reorder the FS_INSTALL install/uninstall tests so the extension's install state flips once each direction instead of install/uninstall/install. Co-Authored-By: Claude Sonnet 5 --- test/standard/make-test.bats | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/test/standard/make-test.bats b/test/standard/make-test.bats index 64b7958..9ccdf1f 100755 --- a/test/standard/make-test.bats +++ b/test/standard/make-test.bats @@ -234,6 +234,11 @@ EOF } @test "PGXNTOOL_ENABLE_FS_INSTALL=no removes install's recipe from make test's dry run" { + # Unlike the pgtap DESTDIR-faking test below, `install`'s own recipe isn't + # gated by a file-existence check -- there's no target file named "install" + # for Make to compare mtimes against, so the recipe shows in a dry run + # whenever `install` remains a prerequisite, regardless of whether the + # extension is already installed on disk. No DESTDIR-faking needed here. run make -n test PGXNTOOL_ENABLE_FS_INSTALL=no assert_success assert_not_contains "$output" "install -c -m 644" @@ -245,19 +250,6 @@ EOF assert_contains "$output" "PGXNTOOL_ENABLE_FS_INSTALL must be" } -@test "make test succeeds with PGXNTOOL_ENABLE_FS_INSTALL=no when the extension is already installed" { - skip_if_no_postgres - - # Stands in for "existing mode": the extension is already deployed (here, - # via a normal install) before test/installcheck ever runs, so disabling - # the FS install prerequisite shouldn't stop the suite from passing. - run make install - assert_success - - run make test PGXNTOOL_ENABLE_FS_INSTALL=no - assert_success -} - @test "make test fails with PGXNTOOL_ENABLE_FS_INSTALL=no against a genuinely uninstalled tree" { skip_if_no_postgres @@ -266,16 +258,31 @@ EOF # uninstalled tree that means failure, which is the real-world proof that # `install` genuinely didn't run as a side effect (the structural test # above already proves the edge itself is gone; this proves it matters). + # + # Runs before the "already installed" test below so the install/uninstall + # state change happens once each way (uninstall here, install there) + # instead of install/uninstall/install. run make uninstall assert_success run make test PGXNTOOL_ENABLE_FS_INSTALL=no assert_failure assert_contains "$output" "does not exist" +} + +@test "make test succeeds with PGXNTOOL_ENABLE_FS_INSTALL=no when the extension is already installed" { + skip_if_no_postgres - # Restore installed state for the rest of this file's tests. + # Stands in for "existing mode": the extension is already deployed (here, + # via a normal install) before test/installcheck ever runs, so disabling + # the FS install prerequisite shouldn't stop the suite from passing. Also + # restores installed state after the uninstall test above, for the rest of + # this file's tests. run make install assert_success + + run make test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success } # ---------------------------------------------------------------------------- From 666a3a213856c3ee7fb31ee33dd07aa746dc4984 Mon Sep 17 00:00:00 2001 From: jnasbyupgrade Date: Tue, 8 Sep 2026 16:23:34 -0500 Subject: [PATCH 3/5] make-test.bats: track pgxntool's _CHECK_STALE_EXPECTED_SCRIPT rename Paired pgxntool PR #91 rebases onto upstream/master, which pulls in pgxntool issue #93's rename of internal-only override variables to a _PGXNTOOL_ prefix, including _CHECK_STALE_EXPECTED_SCRIPT -> _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT. Without this, the stub override in the exit-status/output propagation test silently no-ops and the real script runs instead of the stub. Mirrors pgxntool-test#72's rename fix, scoped to just this branch's own test file (that PR's CLAUDE.md/helpers.bash/04-pgtle.bats changes are unrelated pre-existing content, untouched by this branch). Co-Authored-By: Claude Sonnet 5 --- test/standard/make-test.bats | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/standard/make-test.bats b/test/standard/make-test.bats index 9ccdf1f..9d0175a 100755 --- a/test/standard/make-test.bats +++ b/test/standard/make-test.bats @@ -414,7 +414,7 @@ EOF # script must never even be invoked, not merely have a failure from it # ignored. That's a materially stronger claim than "make test succeeds # despite a stale file", so prove it directly: point - # _CHECK_STALE_EXPECTED_SCRIPT -- the one variable the + # _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT -- the one variable the # check-stale-expected recipe actually invokes (see base.mk) -- at a stub # that only touches a marker file and fails. No need to fake out # PGXNTOOL_DIR itself, since this variable is the sole thing standing @@ -426,7 +426,7 @@ EOF local stub_script stub_script=$(make_stub_script check-stale-expected-stub 1 "" "$marker") - run make test PGXNTOOL_ENABLE_CHECK_STALE_EXPECTED=no _CHECK_STALE_EXPECTED_SCRIPT="$stub_script" + run make test PGXNTOOL_ENABLE_CHECK_STALE_EXPECTED=no _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT="$stub_script" assert_success assert_file_not_exists "$marker" } @@ -460,7 +460,7 @@ EOF # base.mk's responsibility, not the script's decision logic (the real # script's distinct exit codes and messages are already covered directly # in check-stale-expected-script.bats): does `make check-stale-expected` - # correctly surface whatever _CHECK_STALE_EXPECTED_SCRIPT does? A + # correctly surface whatever _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT does? A # stub that deterministically prints a message and exits nonzero must # make the target (and `make`'s own recipe-failure handling) fail and # show that message; a stub that exits 0 must let it pass -- regardless @@ -468,13 +468,13 @@ EOF local stub_script stub_script=$(make_stub_script fail-stub 5 "STUB SENTINEL MESSAGE") - run make check-stale-expected _CHECK_STALE_EXPECTED_SCRIPT="$stub_script" + run make check-stale-expected _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT="$stub_script" assert_failure assert_contains "$output" "STUB SENTINEL MESSAGE" stub_script=$(make_stub_script pass-stub 0) - run make check-stale-expected _CHECK_STALE_EXPECTED_SCRIPT="$stub_script" + run make check-stale-expected _PGXNTOOL_CHECK_STALE_EXPECTED_SCRIPT="$stub_script" assert_success } From 107dc63eed9fa22dfb1d2a66a2453c665779d8dc Mon Sep 17 00:00:00 2001 From: jnasbyupgrade Date: Tue, 8 Sep 2026 17:01:45 -0500 Subject: [PATCH 4/5] Address PR #70 follow-up review: verify install's dry-run behavior, drop a second uninstall Document that install's dry-run visibility comes from having no on-disk file named "install" rather than a .PHONY declaration (checked pgxs.mk and base.mk -- neither marks it phony), per reviewer request to verify rather than assume. Merge the FS_INSTALL=no negative-case check into the existing issue #79 uninstalled-tree test so both share a single uninstall instead of each test uninstalling separately. Co-Authored-By: Claude Sonnet 5 --- test/standard/make-test.bats | 67 ++++++++++++++++-------------------- 1 file changed, 30 insertions(+), 37 deletions(-) diff --git a/test/standard/make-test.bats b/test/standard/make-test.bats index 9d0175a..68af4e3 100755 --- a/test/standard/make-test.bats +++ b/test/standard/make-test.bats @@ -181,20 +181,31 @@ EOF error "installcheck's parsed prerequisite list does not include 'install': $prereq_line" } -@test "make test succeeds from a genuinely uninstalled state (issue #79)" { +@test "make test fails with PGXNTOOL_ENABLE_FS_INSTALL=no, but succeeds by default, from a genuinely uninstalled tree (issues #55, #79)" { skip_if_no_postgres - # The `make -p` test above is the primary proof for this issue (the - # dependency edge genuinely exists in the parsed makefile). This test is a - # complementary real-world sanity check of the whole pipeline: on a - # genuinely uninstalled tree, does pg_regress actually find the extension - # already installed by the time it runs? `make uninstall` forces that - # precondition regardless of what any earlier test in this file already - # installed on the shared PostgreSQL instance -- the original bug was - # historically masked in exactly that way. + # Shares one `make uninstall` for issue #79's original regression check + # and issue #55's proof that install doesn't happen as a side effect + # (below), instead of each uninstalling separately. run make uninstall assert_success + # issue #55: with FS install disabled, nothing reinstalls the extension as + # a side effect, so pg_regress runs against a genuinely uninstalled tree + # and fails. The structural test further below already proves the + # `installcheck: install` edge is genuinely gone; this proves it matters. + run make test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_failure + assert_contains "$output" "does not exist" + + # issue #79: by default, does pg_regress actually find the extension + # already installed by the time it runs? The `make -p` test above is the + # primary proof (the dependency edge genuinely exists in the parsed + # makefile); this is the complementary real-world sanity check of the + # whole pipeline. The original bug was historically masked because some + # earlier test had already installed the extension on the shared + # PostgreSQL instance -- the uninstall above forces the precondition + # regardless. run make test assert_success assert_not_contains "$output" "does not exist" @@ -234,11 +245,13 @@ EOF } @test "PGXNTOOL_ENABLE_FS_INSTALL=no removes install's recipe from make test's dry run" { - # Unlike the pgtap DESTDIR-faking test below, `install`'s own recipe isn't - # gated by a file-existence check -- there's no target file named "install" - # for Make to compare mtimes against, so the recipe shows in a dry run - # whenever `install` remains a prerequisite, regardless of whether the - # extension is already installed on disk. No DESTDIR-faking needed here. + # `install` isn't declared .PHONY (checked both PGXS's pgxs.mk and + # pgxntool's base.mk) -- it's "always out of date" for a plainer reason: + # there's no file literally named "install" on disk for Make to compare a + # timestamp against. That's why the recipe shows in a dry run whenever + # `install` remains a prerequisite, regardless of whether the extension is + # already installed on disk -- unlike the pgtap DESTDIR-faking test below, + # no DESTDIR-faking is needed here. run make -n test PGXNTOOL_ENABLE_FS_INSTALL=no assert_success assert_not_contains "$output" "install -c -m 644" @@ -250,34 +263,14 @@ EOF assert_contains "$output" "PGXNTOOL_ENABLE_FS_INSTALL must be" } -@test "make test fails with PGXNTOOL_ENABLE_FS_INSTALL=no against a genuinely uninstalled tree" { - skip_if_no_postgres - - # Inverse of the issue #79 test above: with filesystem install disabled, - # pg_regress must run against whatever's already there -- on a genuinely - # uninstalled tree that means failure, which is the real-world proof that - # `install` genuinely didn't run as a side effect (the structural test - # above already proves the edge itself is gone; this proves it matters). - # - # Runs before the "already installed" test below so the install/uninstall - # state change happens once each way (uninstall here, install there) - # instead of install/uninstall/install. - run make uninstall - assert_success - - run make test PGXNTOOL_ENABLE_FS_INSTALL=no - assert_failure - assert_contains "$output" "does not exist" -} - @test "make test succeeds with PGXNTOOL_ENABLE_FS_INSTALL=no when the extension is already installed" { skip_if_no_postgres # Stands in for "existing mode": the extension is already deployed (here, # via a normal install) before test/installcheck ever runs, so disabling - # the FS install prerequisite shouldn't stop the suite from passing. Also - # restores installed state after the uninstall test above, for the rest of - # this file's tests. + # the FS install prerequisite shouldn't stop the suite from passing. + # State is already installed at this point, but the explicit install below + # documents the precondition this test actually relies on. run make install assert_success From 5fbfa2ee9233eff3780e8fe9fba51a7c5fb96ec1 Mon Sep 17 00:00:00 2001 From: jnasbyupgrade Date: Tue, 8 Sep 2026 17:49:29 -0500 Subject: [PATCH 5/5] make-test.bats: verify install's dry-run recipe against real uninstalled state The prior version relied on a claim about install's .PHONY status that turned out to be wrong (it IS declared .PHONY via PGXS's Makefile.global, pulled in through pgxs.mk's include chain) -- so the assertion wasn't actually evidence about anything either way. Move the check into the existing genuinely-uninstalled-tree test instead of asserting anything about .PHONY status at all. Co-Authored-By: Claude Sonnet 5 --- test/standard/make-test.bats | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/test/standard/make-test.bats b/test/standard/make-test.bats index 68af4e3..83b6117 100755 --- a/test/standard/make-test.bats +++ b/test/standard/make-test.bats @@ -184,12 +184,22 @@ EOF @test "make test fails with PGXNTOOL_ENABLE_FS_INSTALL=no, but succeeds by default, from a genuinely uninstalled tree (issues #55, #79)" { skip_if_no_postgres - # Shares one `make uninstall` for issue #79's original regression check - # and issue #55's proof that install doesn't happen as a side effect - # (below), instead of each uninstalling separately. + # Shares one `make uninstall` for issue #79's original regression check, + # issue #55's proof that install doesn't happen as a side effect (below), + # and the dry-run recipe check further below, instead of each uninstalling + # separately. run make uninstall assert_success + # `install` is declared .PHONY (via PGXS's Makefile.global, pulled in by + # pgxs.mk's include chain), so its recipe would show in a dry run whenever + # it remains a prerequisite regardless of what's on disk -- checking this + # against a genuinely uninstalled tree (the uninstall above) means the + # result can't be dismissed as coincidental with on-disk state either way. + run make -n test PGXNTOOL_ENABLE_FS_INSTALL=no + assert_success + assert_not_contains "$output" "install -c -m 644" + # issue #55: with FS install disabled, nothing reinstalls the extension as # a side effect, so pg_regress runs against a genuinely uninstalled tree # and fails. The structural test further below already proves the @@ -244,19 +254,6 @@ EOF fi } -@test "PGXNTOOL_ENABLE_FS_INSTALL=no removes install's recipe from make test's dry run" { - # `install` isn't declared .PHONY (checked both PGXS's pgxs.mk and - # pgxntool's base.mk) -- it's "always out of date" for a plainer reason: - # there's no file literally named "install" on disk for Make to compare a - # timestamp against. That's why the recipe shows in a dry run whenever - # `install` remains a prerequisite, regardless of whether the extension is - # already installed on disk -- unlike the pgtap DESTDIR-faking test below, - # no DESTDIR-faking is needed here. - run make -n test PGXNTOOL_ENABLE_FS_INSTALL=no - assert_success - assert_not_contains "$output" "install -c -m 644" -} - @test "PGXNTOOL_ENABLE_FS_INSTALL rejects invalid values" { run make print-PGXNTOOL_ENABLE_FS_INSTALL PGXNTOOL_ENABLE_FS_INSTALL=bogus assert_failure