diff --git a/nix/ext/pg_graphql/default.nix b/nix/ext/pg_graphql/default.nix
index d944d5ede..c72def590 100644
--- a/nix/ext/pg_graphql/default.nix
+++ b/nix/ext/pg_graphql/default.nix
@@ -79,7 +79,7 @@ let
 
         preCheck = ''
           export PGRX_HOME="$(mktemp -d)"
-          export PG_VERSION="${lib.versions.major postgresql.version}"
+          export PG_VERSION="${pgVersion}"
           export NIX_PGLIBDIR="$PGRX_HOME/$PG_VERSION/lib"
           export PATH="$PGRX_HOME/$PG_VERSION/bin:$PATH"
           ${lib.getExe rsync} --chmod=ugo+w -a ${postgresql}/ ${postgresql.lib}/ "$PGRX_HOME/$PG_VERSION/"
@@ -119,8 +119,9 @@ let
       }
     );
   allVersions = (builtins.fromJSON (builtins.readFile ../versions.json)).pg_graphql;
+  pgVersion = lib.versions.major postgresql.version;
   supportedVersions = lib.filterAttrs (
-    _: value: builtins.elem (lib.versions.major postgresql.version) value.postgresql
+    _: value: builtins.elem pgVersion value.postgresql
   ) allVersions;
   versions = lib.naturalSort (lib.attrNames supportedVersions);
   latestVersion = lib.last versions;
@@ -128,10 +129,54 @@ let
   packages = builtins.attrValues (
     lib.mapAttrs (name: value: build name value.hash value.rust value.pgrx) supportedVersions
   );
+  buildUnsupported =
+    # Build SQL-only packages for unsupported versions needed by pg_upgrade.
+    # When upgrading PostgreSQL, pg_upgrade requires old extension versions to exist
+    # even if they can't compile against the new PostgreSQL version.
+    version: hash: _rustVersion: _pgrxVersion:
+    stdenv.mkDerivation {
+      inherit pname version;
+      src = fetchFromGitHub {
+        owner = "supabase";
+        repo = pname;
+        rev = "v${version}";
+        inherit hash;
+      };
+      phases = [ "installPhase" ];
+      installPhase = ''
+        mkdir -p $out/share/postgresql/extension
+        for file in $src/sql/*.sql; do
+          filename=$(basename "$file")
+          if [[ "$filename" != "load_sql_config.sql" && "$filename" != "load_sql_context.sql" ]]; then
+            cat "$file"
+            echo ";"
+          fi
+        done > $out/share/postgresql/extension/${pname}--${version}.sql
+      '';
+      meta = with lib; {
+        description = "GraphQL support for PostreSQL";
+        homepage = "https://github.com/supabase/${pname}";
+        license = licenses.postgresql;
+        inherit (postgresql.meta) platforms;
+      };
+    };
+  unsupportedVersions = lib.filterAttrs (
+    _: value: !builtins.elem pgVersion value.postgresql
+  ) allVersions;
+  unsupportedPackages =
+    if pgVersion == 15 then
+      [ ]
+    else
+      # Include SQL-only packages for PG15 extension versions incompatible with current PG
+      builtins.attrValues (
+        lib.mapAttrs (
+          name: value: buildUnsupported name value.hash value.rust value.pgrx
+        ) unsupportedVersions
+      );
 in
 buildEnv {
   name = pname;
-  paths = packages;
+  paths = packages ++ unsupportedPackages;
   pathsToLink = [
     "/lib"
     "/share/postgresql/extension"
diff --git a/nix/ext/pg_jsonschema/default.nix b/nix/ext/pg_jsonschema/default.nix
index 74742bed5..7a5fa9d3b 100644
--- a/nix/ext/pg_jsonschema/default.nix
+++ b/nix/ext/pg_jsonschema/default.nix
@@ -49,16 +49,6 @@ let
       # update the following array when the pg_jsonschema version is updated
       # required to ensure that extensions update scripts from previous versions are generated
 
-      previousVersions = [
-        "0.3.1"
-        "0.3.0"
-        "0.2.0"
-        "0.1.4"
-        "0.1.3"
-        "0.1.2"
-        "0.1.1"
-        "0.1.0"
-      ];
       CARGO = "${cargo}/bin/cargo";
       #darwin env needs PGPORT to be unique for build to not clash with other pgrx extensions
       env = lib.optionalAttrs stdenv.isDarwin {
@@ -79,19 +69,15 @@ let
 
       preCheck = ''
         export PGRX_HOME=$(mktemp -d)
-        export NIX_PGLIBDIR=$PGRX_HOME/${lib.versions.major postgresql.version}/lib
-        ${lib.getExe pkgs.rsync} --chmod=ugo+w -a ${postgresql}/ ${postgresql.lib}/ $PGRX_HOME/${lib.versions.major postgresql.version}/
-        cargo pgrx init --pg${lib.versions.major postgresql.version} $PGRX_HOME/${lib.versions.major postgresql.version}/bin/pg_config
+        export NIX_PGLIBDIR=$PGRX_HOME/${pgVersion}/lib
+        ${lib.getExe pkgs.rsync} --chmod=ugo+w -a ${postgresql}/ ${postgresql.lib}/ $PGRX_HOME/${pgVersion}/
+        cargo pgrx init --pg${pgVersion} $PGRX_HOME/${pgVersion}/bin/pg_config
       '';
 
       doCheck = true;
 
-      preBuild = ''
-        echo "Processing git tags..."
-        echo '${builtins.concatStringsSep "," previousVersions}' | sed 's/,/\n/g' > git_tags.txt
-      '';
-
       postInstall = ''
+        find $out
         mv $out/lib/${pname}${postgresql.dlSuffix} $out/lib/${pname}-${version}${postgresql.dlSuffix}
 
         create_control_files() {
@@ -120,8 +106,9 @@ let
       };
     };
   allVersions = (builtins.fromJSON (builtins.readFile ../versions.json)).pg_jsonschema;
+  pgVersion = lib.versions.major postgresql.version;
   supportedVersions = lib.filterAttrs (
-    _: value: builtins.elem (lib.versions.major postgresql.version) value.postgresql
+    _: value: builtins.elem pgVersion value.postgresql
   ) allVersions;
   versions = lib.naturalSort (lib.attrNames supportedVersions);
   latestVersion = lib.last versions;
@@ -129,6 +116,8 @@ let
   packages = builtins.attrValues (
     lib.mapAttrs (name: value: build name value.hash value.rust value.pgrx) supportedVersions
   );
+  unsupportedVersionsItems = lib.filterAttrs (_: value: value.postgresql == [ "15" ]) allVersions;
+  unsupportedVersions = if pgVersion == "17" then lib.attrNames unsupportedVersionsItems else [ ];
 in
 pkgs.buildEnv {
   name = pname;
@@ -145,6 +134,10 @@ pkgs.buildEnv {
        }"
     )
 
+    for v in ${lib.concatStringsSep " " unsupportedVersions}; do
+      cp $out/share/postgresql/extension/${pname}--${lib.head versions}.sql $out/share/postgresql/extension/${pname}--$v.sql
+    done
+
     create_sql_files() {
       PREVIOUS_VERSION=""
       while IFS= read -r i; do
diff --git a/nix/ext/tests/default.nix b/nix/ext/tests/default.nix
index e1401c004..23c74c398 100644
--- a/nix/ext/tests/default.nix
+++ b/nix/ext/tests/default.nix
@@ -136,9 +136,6 @@ let
         };
       testScript =
         { nodes, ... }:
-        let
-          pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-        in
         ''
           from pathlib import Path
           versions = {
@@ -146,7 +143,9 @@ let
             "17": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "17"))}],
           }
           extension_name = "${pname}"
-          pg17_configuration = "${pg17-configuration}"
+          system = "${nodes.server.system.build.toplevel}"
+          pg15_configuration = system
+          pg17_configuration = f"{system}/specialisation/postgresql17"
           ext_has_background_worker = ${
             if (installedExtension "15") ? hasBackgroundWorker then "True" else "False"
           }
@@ -198,6 +197,33 @@ let
 
           with subtest("Check pg_regress with postgresql 17 after installing the last version"):
             test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+          with subtest("Test pg_upgrade from postgresql 15 to 17 with older extension version"):
+            # Test that all extension versions from postgresql 15 can be upgraded to postgresql 17 using pg_upgrade
+            for version in versions["15"]:
+              server.systemctl("stop postgresql.service")
+              server.succeed("rm -fr /var/lib/postgresql/update_extensions.sql /var/lib/postgresql/17")
+              server.succeed(
+                f"{pg15_configuration}/bin/switch-to-configuration test >&2"
+              )
+              test.drop_extension()
+              test.install_extension(version)
+              server.succeed(
+                f"{pg17_configuration}/bin/switch-to-configuration test >&2"
+              )
+              has_update_script = server.succeed(
+                "test -f /var/lib/postgresql/update_extensions.sql && echo 'yes' || echo 'no'"
+              ).strip() == "yes"
+              if has_update_script:
+                # Run the extension update script generated during the upgrade
+                test.run_sql_file("/var/lib/postgresql/update_extensions.sql")
+                # If there was an update script, the last version should be installed
+                test.assert_version_matches(versions["17"][-1])
+              else:
+                # Otherwise, the version should match the version from postgresql 15
+                test.assert_version_matches(version)
+
+              test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
         '';
     };
 in
@@ -217,12 +243,13 @@ builtins.listToAttrs (
       "hypopg"
       "index_advisor"
       "pg_cron"
-      "pg_hashids"
       "pg_graphql"
+      "pg_hashids"
       "pg_jsonschema"
       "pg_net"
-      "pgaudit"
       "pg_tle"
+      "pgaudit"
+      "postgis"
       "vector"
       "wrappers"
     ]
diff --git a/nix/ext/tests/lib.py b/nix/ext/tests/lib.py
index 42b5eb361..a28361c3b 100644
--- a/nix/ext/tests/lib.py
+++ b/nix/ext/tests/lib.py
@@ -47,7 +47,7 @@ def run_sql_file(self, file: str) -> str:
         ).strip()
 
     def drop_extension(self):
-        self.run_sql(f"DROP EXTENSION IF EXISTS {self.extension_name};")
+        self.run_sql(f"DROP EXTENSION IF EXISTS {self.extension_name} CASCADE;")
 
     def install_extension(self, version: str):
         self.run_sql(
diff --git a/nix/ext/tests/pgmq.nix b/nix/ext/tests/pgmq.nix
index 94438d612..e0fe1d826 100644
--- a/nix/ext/tests/pgmq.nix
+++ b/nix/ext/tests/pgmq.nix
@@ -39,7 +39,7 @@ let
   psql_17 = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17;
 in
 self.inputs.nixpkgs.lib.nixos.runTest {
-  name = "timescaledb";
+  name = "pgmq";
   hostPkgs = pkgs;
   nodes.server =
     { config, ... }:
@@ -105,9 +105,6 @@ self.inputs.nixpkgs.lib.nixos.runTest {
     };
   testScript =
     { nodes, ... }:
-    let
-      pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-    in
     ''
       from pathlib import Path
       versions = {
@@ -116,7 +113,9 @@ self.inputs.nixpkgs.lib.nixos.runTest {
       }
       extension_name = "${pname}"
       support_upgrade = True
-      pg17_configuration = "${pg17-configuration}"
+      system = "${nodes.server.system.build.toplevel}"
+      pg15_configuration = system
+      pg17_configuration = f"{system}/specialisation/postgresql17"
       ext_has_background_worker = ${
         if (installedExtension "15") ? hasBackgroundWorker then "True" else "False"
       }
@@ -173,5 +172,30 @@ self.inputs.nixpkgs.lib.nixos.runTest {
 
       with subtest("Check pg_regress with postgresql 17 after installing the last version"):
         test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+      with subtest("Test pg_upgrade from postgresql 15 to 17 with older extension version"):
+        # Test that all extension versions from postgresql 15 can be upgraded to postgresql 17 using pg_upgrade
+        for version in versions["15"]:
+          server.systemctl("stop postgresql.service")
+          server.succeed("rm -fr /var/lib/postgresql/update_extensions.sql /var/lib/postgresql/17")
+          server.succeed(
+            f"{pg15_configuration}/bin/switch-to-configuration test >&2"
+          )
+          test.drop_extension()
+          test.install_extension(version)
+          server.succeed(
+            f"{pg17_configuration}/bin/switch-to-configuration test >&2"
+          )
+          has_update_script = server.succeed(
+            "test -f /var/lib/postgresql/update_extensions.sql && echo 'yes' || echo 'no'"
+          ).strip() == "yes"
+          if has_update_script:
+            # Run the extension update script generated during the upgrade
+            test.run_sql_file("/var/lib/postgresql/update_extensions.sql")
+            # If there was an update script, the last version should be installed
+            test.assert_version_matches(versions["17"][-1])
+          else:
+            # Otherwise, the version should match the version from postgresql 15
+            test.assert_version_matches(version)
     '';
 }
diff --git a/nix/ext/tests/pgroonga.nix b/nix/ext/tests/pgroonga.nix
index 83af20ac8..54d5627f9 100644
--- a/nix/ext/tests/pgroonga.nix
+++ b/nix/ext/tests/pgroonga.nix
@@ -125,9 +125,6 @@ self.inputs.nixpkgs.lib.nixos.runTest {
     };
   testScript =
     { nodes, ... }:
-    let
-      pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-    in
     ''
       from pathlib import Path
       versions = {
@@ -135,7 +132,9 @@ self.inputs.nixpkgs.lib.nixos.runTest {
         "17": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "17"))}],
       }
       extension_name = "${pname}"
-      pg17_configuration = "${pg17-configuration}"
+      system = "${nodes.server.system.build.toplevel}"
+      pg15_configuration = system
+      pg17_configuration = f"{system}/specialisation/postgresql17"
       ext_has_background_worker = ${
         if (installedExtension "15") ? hasBackgroundWorker then "True" else "False"
       }
@@ -187,5 +186,32 @@ self.inputs.nixpkgs.lib.nixos.runTest {
 
       with subtest("Check pg_regress with postgresql 17 after installing the last version"):
         test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+      with subtest("Test pg_upgrade from postgresql 15 to 17 with older extension version"):
+        # Test that all extension versions from postgresql 15 can be upgraded to postgresql 17 using pg_upgrade
+        for version in versions["15"]:
+          server.systemctl("stop postgresql.service")
+          server.succeed("rm -fr /var/lib/postgresql/update_extensions.sql /var/lib/postgresql/17")
+          server.succeed(
+            f"{pg15_configuration}/bin/switch-to-configuration test >&2"
+          )
+          test.drop_extension()
+          test.install_extension(version)
+          server.succeed(
+            f"{pg17_configuration}/bin/switch-to-configuration test >&2"
+          )
+          has_update_script = server.succeed(
+            "test -f /var/lib/postgresql/update_extensions.sql && echo 'yes' || echo 'no'"
+          ).strip() == "yes"
+          if has_update_script:
+            # Run the extension update script generated during the upgrade
+            test.run_sql_file("/var/lib/postgresql/update_extensions.sql")
+            # If there was an update script, the last version should be installed
+            test.assert_version_matches(versions["17"][-1])
+          else:
+            # Otherwise, the version should match the version from postgresql 15
+            test.assert_version_matches(version)
+
+          test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
     '';
 }
diff --git a/nix/ext/tests/pgsodium.nix b/nix/ext/tests/pgsodium.nix
index 9ad1aec4b..f97c8b3de 100644
--- a/nix/ext/tests/pgsodium.nix
+++ b/nix/ext/tests/pgsodium.nix
@@ -41,6 +41,8 @@ let
       echo 0000000000000000000000000000000000000000000000000000000000000000
     ''
   );
+  psql_15 = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_15;
+  psql_17 = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17;
 in
 self.inputs.nixpkgs.lib.nixos.runTest {
   name = pname;
@@ -60,7 +62,21 @@ self.inputs.nixpkgs.lib.nixos.runTest {
 
       services.postgresql = {
         enable = true;
-        package = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_15;
+        package = psql_15;
+        authentication = ''
+          local all postgres peer map=postgres
+          local all all peer map=root
+        '';
+        identMap = ''
+          root root supabase_admin
+          postgres postgres postgres
+        '';
+        ensureUsers = [
+          {
+            name = "supabase_admin";
+            ensureClauses.superuser = true;
+          }
+        ];
         settings = {
           "shared_preload_libraries" = pname;
           "pgsodium.getkey_script" = pgsodiumGetKey;
@@ -69,7 +85,7 @@ self.inputs.nixpkgs.lib.nixos.runTest {
 
       specialisation.postgresql17.configuration = {
         services.postgresql = {
-          package = lib.mkForce (postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17);
+          package = lib.mkForce psql_17;
         };
 
         systemd.services.postgresql-migrate = {
@@ -83,8 +99,8 @@ self.inputs.nixpkgs.lib.nixos.runTest {
           };
           script =
             let
-              oldPostgresql = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_15;
-              newPostgresql = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17;
+              oldPostgresql = psql_15;
+              newPostgresql = psql_17;
               oldDataDir = "${builtins.dirOf config.services.postgresql.dataDir}/${oldPostgresql.psqlSchema}";
               newDataDir = "${builtins.dirOf config.services.postgresql.dataDir}/${newPostgresql.psqlSchema}";
             in
@@ -110,49 +126,93 @@ self.inputs.nixpkgs.lib.nixos.runTest {
     };
   testScript =
     { nodes, ... }:
-    let
-      pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-    in
     ''
+      from pathlib import Path
       versions = {
         "15": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "15"))}],
         "17": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "17"))}],
       }
+      extension_name = "${pname}"
+      system = "${nodes.server.system.build.toplevel}"
+      pg15_configuration = system
+      pg17_configuration = f"{system}/specialisation/postgresql17"
+      ext_has_background_worker = ${
+        if (installedExtension "15") ? hasBackgroundWorker then "True" else "False"
+      }
+      sql_test_directory = Path("${../../tests}")
+      pg_regress_test_name = "${(installedExtension "15").pgRegressTestName or pname}"
 
-      def run_sql(query):
-        return server.succeed(f"""sudo -u postgres psql -t -A -F\",\" -c \"{query}\" """).strip()
-
-      def check_upgrade_path(pg_version):
-        with subtest("Check ${pname} upgrade path"):
-          firstVersion = versions[pg_version][0]
-          server.succeed("sudo -u postgres psql -c 'DROP EXTENSION IF EXISTS ${pname};'")
-          run_sql(f"""CREATE EXTENSION ${pname} WITH VERSION '{firstVersion}' CASCADE;""")
-          installed_version = run_sql(r"""SELECT extversion FROM pg_extension WHERE extname = '${pname}';""")
-          assert installed_version == firstVersion, f"Expected ${pname} version {firstVersion}, but found {installed_version}"
-          for version in versions[pg_version][1:]:
-            run_sql(f"""ALTER EXTENSION ${pname} UPDATE TO '{version}';""")
-            installed_version = run_sql(r"""SELECT extversion FROM pg_extension WHERE extname = '${pname}';""")
-            assert installed_version == version, f"Expected ${pname} version {version}, but found {installed_version}"
+      ${builtins.readFile ./lib.py}
 
       start_all()
 
       server.wait_for_unit("multi-user.target")
       server.wait_for_unit("postgresql.service")
 
-      check_upgrade_path("15")
+      test = PostgresExtensionTest(server, extension_name, versions, sql_test_directory)
+
+      with subtest("Check upgrade path with postgresql 15"):
+        test.check_upgrade_path("15")
 
-      with subtest("Check ${pname} latest extension version"):
-        server.succeed("sudo -u postgres psql -c 'DROP EXTENSION ${pname};'")
-        server.succeed("sudo -u postgres psql -c 'CREATE EXTENSION ${pname} CASCADE;'")
-        installed_extensions=run_sql(r"""SELECT extname, extversion FROM pg_extension;""")
-        latestVersion = versions["15"][-1]
-        assert f"${pname},{latestVersion}" in installed_extensions
+      with subtest("Check pg_regress with postgresql 15 after extension upgrade"):
+        test.check_pg_regress(Path("${psql_15}/lib/pgxs/src/test/regress/pg_regress"), "15", pg_regress_test_name)
+
+      last_version = None
+      with subtest("Check the install of the last version of the extension"):
+        last_version = test.check_install_last_version("15")
+
+      if ext_has_background_worker:
+        with subtest("Test switch_${pname}_version"):
+          test.check_switch_extension_with_background_worker(Path("${psql_15}/lib/${pname}.so"), "15")
+
+      with subtest("Check pg_regress with postgresql 15 after installing the last version"):
+        test.check_pg_regress(Path("${psql_15}/lib/pgxs/src/test/regress/pg_regress"), "15", pg_regress_test_name)
 
       with subtest("switch to postgresql 17"):
         server.succeed(
-          "${pg17-configuration}/bin/switch-to-configuration test >&2"
+          f"{pg17_configuration}/bin/switch-to-configuration test >&2"
         )
 
-      check_upgrade_path("17")
+      with subtest("Check last version of the extension after postgresql upgrade"):
+        test.assert_version_matches(last_version)
+
+      with subtest("Check upgrade path with postgresql 17"):
+        test.check_upgrade_path("17")
+
+      with subtest("Check pg_regress with postgresql 17 after extension upgrade"):
+        test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+      with subtest("Check the install of the last version of the extension"):
+        test.check_install_last_version("17")
+
+      with subtest("Check pg_regress with postgresql 17 after installing the last version"):
+        test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+      with subtest("Test pg_upgrade from postgresql 15 to 17 with older extension version"):
+        # Test that all extension versions from postgresql 15 can be upgraded to postgresql 17 using pg_upgrade
+        for version in versions["15"]:
+          server.systemctl("stop postgresql.service")
+          server.succeed("rm -fr /var/lib/postgresql/update_extensions.sql /var/lib/postgresql/17")
+          server.succeed(
+            f"{pg15_configuration}/bin/switch-to-configuration test >&2"
+          )
+          test.drop_extension()
+          test.install_extension(version)
+          server.succeed(
+            f"{pg17_configuration}/bin/switch-to-configuration test >&2"
+          )
+          has_update_script = server.succeed(
+            "test -f /var/lib/postgresql/update_extensions.sql && echo 'yes' || echo 'no'"
+          ).strip() == "yes"
+          if has_update_script:
+            # Run the extension update script generated during the upgrade
+            test.run_sql_file("/var/lib/postgresql/update_extensions.sql")
+            # If there was an update script, the last version should be installed
+            test.assert_version_matches(versions["17"][-1])
+          else:
+            # Otherwise, the version should match the version from postgresql 15
+            test.assert_version_matches(version)
+
+          test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
     '';
 }
diff --git a/nix/ext/tests/postgis.nix b/nix/ext/tests/postgis.nix
deleted file mode 100644
index ab6a4b3f8..000000000
--- a/nix/ext/tests/postgis.nix
+++ /dev/null
@@ -1,156 +0,0 @@
-{ self, pkgs }:
-let
-  pname = "postgis";
-  inherit (pkgs) lib;
-  installedExtension =
-    postgresMajorVersion: self.packages.${pkgs.system}."psql_${postgresMajorVersion}/exts/${pname}-all";
-  versions = postgresqlMajorVersion: (installedExtension postgresqlMajorVersion).versions;
-  postgresqlWithExtension =
-    postgresql:
-    let
-      majorVersion = lib.versions.major postgresql.version;
-      pkg = pkgs.buildEnv {
-        name = "postgresql-${majorVersion}-${pname}";
-        paths = [
-          postgresql
-          postgresql.lib
-          (installedExtension majorVersion)
-        ];
-        passthru = {
-          inherit (postgresql) version psqlSchema;
-          lib = pkg;
-          withPackages = _: pkg;
-        };
-        nativeBuildInputs = [ pkgs.makeWrapper ];
-        pathsToLink = [
-          "/"
-          "/bin"
-          "/lib"
-        ];
-        postBuild = ''
-          wrapProgram $out/bin/postgres --set NIX_PGLIBDIR $out/lib
-          wrapProgram $out/bin/pg_ctl --set NIX_PGLIBDIR $out/lib
-          wrapProgram $out/bin/pg_upgrade --set NIX_PGLIBDIR $out/lib
-        '';
-      };
-    in
-    pkg;
-in
-self.inputs.nixpkgs.lib.nixos.runTest {
-  name = pname;
-  hostPkgs = pkgs;
-  nodes.server =
-    { config, ... }:
-    {
-      virtualisation = {
-        forwardPorts = [
-          {
-            from = "host";
-            host.port = 13022;
-            guest.port = 22;
-          }
-        ];
-      };
-      services.openssh = {
-        enable = true;
-      };
-
-      services.postgresql = {
-        enable = true;
-        package = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_15;
-      };
-
-      specialisation.postgresql17.configuration = {
-        services.postgresql = {
-          package = lib.mkForce (postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17);
-        };
-
-        systemd.services.postgresql-migrate = {
-          serviceConfig = {
-            Type = "oneshot";
-            RemainAfterExit = true;
-            User = "postgres";
-            Group = "postgres";
-            StateDirectory = "postgresql";
-            WorkingDirectory = "${builtins.dirOf config.services.postgresql.dataDir}";
-          };
-          script =
-            let
-              oldPostgresql = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_15;
-              newPostgresql = postgresqlWithExtension self.packages.${pkgs.system}.postgresql_17;
-              oldDataDir = "${builtins.dirOf config.services.postgresql.dataDir}/${oldPostgresql.psqlSchema}";
-              newDataDir = "${builtins.dirOf config.services.postgresql.dataDir}/${newPostgresql.psqlSchema}";
-            in
-            ''
-              if [[ ! -d ${newDataDir} ]]; then
-                install -d -m 0700 -o postgres -g postgres "${newDataDir}"
-                ${newPostgresql}/bin/initdb -D "${newDataDir}"
-                ${newPostgresql}/bin/pg_upgrade --old-datadir "${oldDataDir}" --new-datadir "${newDataDir}" \
-                  --old-bindir "${oldPostgresql}/bin" --new-bindir "${newPostgresql}/bin"
-              else
-                echo "${newDataDir} already exists"
-              fi
-            '';
-        };
-
-        systemd.services.postgresql = {
-          after = [ "postgresql-migrate.service" ];
-          requires = [ "postgresql-migrate.service" ];
-        };
-      };
-    };
-  testScript =
-    { nodes, ... }:
-    let
-      pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-    in
-    ''
-      versions = {
-        "15": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "15"))}],
-        "17": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "17"))}],
-      }
-
-      def run_sql(query):
-        return server.succeed(f"""sudo -u postgres psql -t -A -F\",\" -c \"{query}\" """).strip()
-
-      def check_upgrade_path(pg_version):
-        with subtest("Check ${pname} upgrade path"):
-          firstVersion = versions[pg_version][0]
-          server.succeed("sudo -u postgres psql -c 'DROP EXTENSION IF EXISTS ${pname};'")
-          run_sql(f"""CREATE EXTENSION ${pname} WITH VERSION '{firstVersion}' CASCADE;""")
-          installed_version = run_sql(r"""SELECT extversion FROM pg_extension WHERE extname = '${pname}';""")
-          assert installed_version == firstVersion, f"Expected ${pname} version {firstVersion}, but found {installed_version}"
-          for version in versions[pg_version][1:]:
-            run_sql(f"""ALTER EXTENSION ${pname} UPDATE TO '{version}';""")
-            installed_version = run_sql(r"""SELECT extversion FROM pg_extension WHERE extname = '${pname}';""")
-            assert installed_version == version, f"Expected ${pname} version {version}, but found {installed_version}"
-
-      start_all()
-
-      server.wait_for_unit("multi-user.target")
-      server.wait_for_unit("postgresql.service")
-
-      check_upgrade_path("15")
-
-      with subtest("Check ${pname} latest extension version"):
-        server.succeed("sudo -u postgres psql -c 'DROP EXTENSION ${pname};'")
-        server.succeed("sudo -u postgres psql -c 'CREATE EXTENSION ${pname} CASCADE;'")
-        installed_extensions=run_sql(r"""SELECT extname, extversion FROM pg_extension where extname = '${pname}';""")
-        latestVersion = versions["15"][-1]
-        majMinVersion = ".".join(latestVersion.split('.')[:1])
-        assert f"${pname},{majMinVersion}" in installed_extensions, f"Expected ${pname} version {latestVersion}, but found {installed_extensions}"
-
-      with subtest("switch to postgresql 17"):
-        server.succeed(
-          "${pg17-configuration}/bin/switch-to-configuration test >&2"
-        )
-
-      with subtest("Check ${pname} latest extension version after upgrade"):
-        installed_extensions=run_sql(r"""SELECT extname, extversion FROM pg_extension;""")
-        latestVersion = versions["17"][-1]
-        majMinVersion = ".".join(latestVersion.split('.')[:1])
-        assert f"${pname},{majMinVersion}" in installed_extensions
-
-      check_upgrade_path("17")
-    '';
-}
diff --git a/nix/ext/tests/vault.nix b/nix/ext/tests/vault.nix
index 7b16247a5..480ef5ec9 100644
--- a/nix/ext/tests/vault.nix
+++ b/nix/ext/tests/vault.nix
@@ -133,9 +133,6 @@ self.inputs.nixpkgs.lib.nixos.runTest {
     };
   testScript =
     { nodes, ... }:
-    let
-      pg17-configuration = "${nodes.server.system.build.toplevel}/specialisation/postgresql17";
-    in
     ''
       from pathlib import Path
       versions = {
@@ -143,8 +140,10 @@ self.inputs.nixpkgs.lib.nixos.runTest {
         "17": [${lib.concatStringsSep ", " (map (s: ''"${s}"'') (versions "17"))}],
       }
       extension_name = "${pname}"
+      system = "${nodes.server.system.build.toplevel}"
+      pg15_configuration = system
+      pg17_configuration = f"{system}/specialisation/postgresql17"
       support_upgrade = True
-      pg17_configuration = "${pg17-configuration}"
       ext_has_background_worker = ${
         if (installedExtension "15") ? hasBackgroundWorker then "True" else "False"
       }
@@ -197,5 +196,33 @@ self.inputs.nixpkgs.lib.nixos.runTest {
       with subtest("Check pg_regress with postgresql 17 after installing the last version"):
         test.run_sql_file("${../../../ansible/files/postgresql_extension_custom_scripts/supabase_vault/after-create.sql}")
         test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
+
+      with subtest("Test pg_upgrade from postgresql 15 to 17 with older extension version"):
+        # Test that all extension versions from postgresql 15 can be upgraded to postgresql 17 using pg_upgrade
+        for version in versions["15"]:
+          server.systemctl("stop postgresql.service")
+          server.succeed("rm -fr /var/lib/postgresql/update_extensions.sql /var/lib/postgresql/17")
+          server.succeed(
+            f"{pg15_configuration}/bin/switch-to-configuration test >&2"
+          )
+          test.drop_extension()
+          test.install_extension(version)
+          server.succeed(
+            f"{pg17_configuration}/bin/switch-to-configuration test >&2"
+          )
+          has_update_script = server.succeed(
+            "test -f /var/lib/postgresql/update_extensions.sql && echo 'yes' || echo 'no'"
+          ).strip() == "yes"
+          if has_update_script:
+            # Run the extension update script generated during the upgrade
+            test.run_sql_file("/var/lib/postgresql/update_extensions.sql")
+            # If there was an update script, the last version should be installed
+            test.assert_version_matches(versions["17"][-1])
+          else:
+            # Otherwise, the version should match the version from postgresql 15
+            test.assert_version_matches(version)
+
+          test.run_sql_file("${../../../ansible/files/postgresql_extension_custom_scripts/supabase_vault/after-create.sql}")
+          test.check_pg_regress(Path("${psql_17}/lib/pgxs/src/test/regress/pg_regress"), "17", pg_regress_test_name)
     '';
 }