@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.4

package/src/core/objects/procedure/changes/procedure.alter.test.ts

@@ -0,0 +1,1005 @@
+import { describe, expect, test } from "bun:test";
+import { Procedure, type ProcedureProps } from "../procedure.model.ts";
+import {
+  AlterProcedureChangeOwner,
+  AlterProcedureSetConfig,
+  AlterProcedureSetLeakproof,
+  AlterProcedureSetParallel,
+  AlterProcedureSetSecurity,
+  AlterProcedureSetStrictness,
+  AlterProcedureSetVolatility,
+} from "./procedure.alter.ts";
+
+describe.concurrent("procedure", () => {
+  describe("alter", () => {
+    test("change owner", () => {
+      const props: Omit<ProcedureProps, "owner"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterProcedureChangeOwner({
+        procedure,
+        owner: "new_owner",
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure OWNER TO new_owner",
+      );
+    });
+
+    test("change owner (function)", () => {
+      const props: Omit<ProcedureProps, "owner"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+        config: null,
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterProcedureChangeOwner({
+        procedure,
+        owner: "new_owner",
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function OWNER TO new_owner",
+      );
+    });
+
+    test("set security definer", () => {
+      const props: Omit<ProcedureProps, "security_definer"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...props, security_definer: false });
+      const change = new AlterProcedureSetSecurity({
+        procedure,
+        securityDefiner: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function SECURITY DEFINER",
+      );
+    });
+
+    test("unset security definer (invoker)", () => {
+      const props: Omit<ProcedureProps, "security_definer"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...props, security_definer: true });
+      const change = new AlterProcedureSetSecurity({
+        procedure,
+        securityDefiner: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function SECURITY INVOKER",
+      );
+    });
+
+    test("set and reset config", () => {
+      const base: Omit<ProcedureProps, "config"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({
+        ...base,
+        config: ["search_path=public"],
+      });
+      const change1 = new AlterProcedureSetConfig({
+        procedure,
+        action: "reset",
+        key: "search_path",
+      });
+      const change2 = new AlterProcedureSetConfig({
+        procedure,
+        action: "set",
+        key: "search_path",
+        value: "pg_temp",
+      });
+      const change3 = new AlterProcedureSetConfig({
+        procedure,
+        action: "set",
+        key: "work_mem",
+        value: "64MB",
+      });
+      expect(change1.serialize()).toBe(
+        "ALTER FUNCTION public.test_function RESET search_path",
+      );
+      expect(change2.serialize()).toBe(
+        "ALTER FUNCTION public.test_function SET search_path TO pg_temp",
+      );
+      expect(change3.serialize()).toBe(
+        "ALTER FUNCTION public.test_function SET work_mem TO '64MB'",
+      );
+    });
+
+    test("set config from null (function)", () => {
+      const base: Omit<ProcedureProps, "config"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql AS $$SELECT 1$$",
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, config: null });
+      const change = new AlterProcedureSetConfig({
+        procedure,
+        action: "set",
+        key: "search_path",
+        value: "public",
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function SET search_path TO public",
+      );
+    });
+
+    test("set volatility", () => {
+      const base: Omit<ProcedureProps, "volatility"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, volatility: "v" });
+      const change = new AlterProcedureSetVolatility({
+        procedure,
+        volatility: "i",
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function IMMUTABLE",
+      );
+    });
+
+    test("set strictness", () => {
+      const base: Omit<ProcedureProps, "is_strict"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, is_strict: false });
+      const change = new AlterProcedureSetStrictness({
+        procedure,
+        isStrict: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function STRICT",
+      );
+    });
+
+    test("unset strictness (called on null input)", () => {
+      const base: Omit<ProcedureProps, "is_strict"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, is_strict: true });
+      const change = new AlterProcedureSetStrictness({
+        procedure,
+        isStrict: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function CALLED ON NULL INPUT",
+      );
+    });
+
+    test("set leakproof", () => {
+      const base: Omit<ProcedureProps, "leakproof"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, leakproof: false });
+      const change = new AlterProcedureSetLeakproof({
+        procedure,
+        leakproof: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function LEAKPROOF",
+      );
+    });
+
+    test("unset leakproof", () => {
+      const base: Omit<ProcedureProps, "leakproof"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, leakproof: true });
+      const change = new AlterProcedureSetLeakproof({
+        procedure,
+        leakproof: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function NOT LEAKPROOF",
+      );
+    });
+
+    test("set parallel safety", () => {
+      const base: Omit<ProcedureProps, "parallel_safety"> = {
+        schema: "public",
+        name: "test_function",
+        kind: "f",
+        return_type: "int4",
+        return_type_schema: "pg_catalog",
+        language: "sql",
+        security_definer: false,
+        volatility: "v",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: null,
+        binary_path: null,
+        sql_body: "SELECT 1",
+        definition:
+          "CREATE OR REPLACE FUNCTION public.test_function() RETURNS int4 LANGUAGE sql IMMUTABLE AS $$SELECT 1$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, parallel_safety: "u" });
+      const change = new AlterProcedureSetParallel({
+        procedure,
+        parallelSafety: "r",
+      });
+      expect(change.serialize()).toBe(
+        "ALTER FUNCTION public.test_function PARALLEL RESTRICTED",
+      );
+    });
+
+    // PROCEDURE variants
+    test("procedure: set security definer", () => {
+      const base: Omit<ProcedureProps, "security_definer"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, security_definer: false });
+      const change = new AlterProcedureSetSecurity({
+        procedure,
+        securityDefiner: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure SECURITY DEFINER",
+      );
+    });
+
+    test("procedure: unset security definer (invoker)", () => {
+      const base: Omit<ProcedureProps, "security_definer"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, security_definer: true });
+      const change = new AlterProcedureSetSecurity({
+        procedure,
+        securityDefiner: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure SECURITY INVOKER",
+      );
+    });
+
+    test("procedure: set and reset config", () => {
+      const base: Omit<ProcedureProps, "config"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const main = new Procedure({ ...base, config: ["search_path=public"] });
+      const change1 = new AlterProcedureSetConfig({
+        procedure: main,
+        action: "reset",
+        key: "search_path",
+      });
+      const change2 = new AlterProcedureSetConfig({
+        procedure: main,
+        action: "set",
+        key: "search_path",
+        value: "pg_temp",
+      });
+      const change3 = new AlterProcedureSetConfig({
+        procedure: main,
+        action: "set",
+        key: "work_mem",
+        value: "64MB",
+      });
+      expect(change1.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure RESET search_path",
+      );
+      expect(change2.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure SET search_path TO pg_temp",
+      );
+      expect(change3.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure SET work_mem TO '64MB'",
+      );
+    });
+
+    test("procedure: reset all config (to null)", () => {
+      const base: Omit<ProcedureProps, "config"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const main = new Procedure({
+        ...base,
+        config: ["search_path=public", "work_mem=64MB"],
+      });
+      const change1 = new AlterProcedureSetConfig({
+        procedure: main,
+        action: "reset",
+        key: "search_path",
+      });
+      const change2 = new AlterProcedureSetConfig({
+        procedure: main,
+        action: "reset",
+        key: "work_mem",
+      });
+      expect(change1.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure RESET search_path",
+      );
+      expect(change2.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure RESET work_mem",
+      );
+    });
+
+    test("procedure: set volatility", () => {
+      const base: Omit<ProcedureProps, "volatility"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        parallel_safety: "u",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, volatility: "v" });
+      const change = new AlterProcedureSetVolatility({
+        procedure,
+        volatility: "s",
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure STABLE",
+      );
+    });
+
+    test("procedure: set strictness", () => {
+      const base: Omit<ProcedureProps, "is_strict"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, is_strict: false });
+      const change = new AlterProcedureSetStrictness({
+        procedure,
+        isStrict: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure STRICT",
+      );
+    });
+
+    test("procedure: unset strictness (called on null input)", () => {
+      const base: Omit<ProcedureProps, "is_strict"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, is_strict: true });
+      const change = new AlterProcedureSetStrictness({
+        procedure,
+        isStrict: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure CALLED ON NULL INPUT",
+      );
+    });
+
+    test("procedure: set leakproof", () => {
+      const base: Omit<ProcedureProps, "leakproof"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, leakproof: false });
+      const change = new AlterProcedureSetLeakproof({
+        procedure,
+        leakproof: true,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure LEAKPROOF",
+      );
+    });
+
+    test("procedure: unset leakproof", () => {
+      const base: Omit<ProcedureProps, "leakproof"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        parallel_safety: "u",
+        is_strict: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, leakproof: true });
+      const change = new AlterProcedureSetLeakproof({
+        procedure,
+        leakproof: false,
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure NOT LEAKPROOF",
+      );
+    });
+
+    test("procedure: set parallel safety", () => {
+      const base: Omit<ProcedureProps, "parallel_safety"> = {
+        schema: "public",
+        name: "test_procedure",
+        kind: "p",
+        return_type: "void",
+        return_type_schema: "pg_catalog",
+        language: "plpgsql",
+        security_definer: false,
+        volatility: "v",
+        is_strict: false,
+        leakproof: false,
+        returns_set: false,
+        argument_count: 0,
+        argument_default_count: 0,
+        argument_names: null,
+        argument_types: null,
+        all_argument_types: null,
+        argument_modes: null,
+        argument_defaults: null,
+        source_code: "BEGIN RETURN; END;",
+        binary_path: null,
+        sql_body: null,
+        definition:
+          "CREATE OR REPLACE PROCEDURE public.test_procedure() LANGUAGE plpgsql AS $$BEGIN RETURN; END;$$",
+        config: null,
+        owner: "test",
+        execution_cost: 0,
+        result_rows: 0,
+        comment: null,
+        privileges: [],
+      };
+      const procedure = new Procedure({ ...base, parallel_safety: "u" });
+      const change = new AlterProcedureSetParallel({
+        procedure,
+        parallelSafety: "s",
+      });
+      expect(change.serialize()).toBe(
+        "ALTER PROCEDURE public.test_procedure PARALLEL SAFE",
+      );
+    });
+  });
+});