@powerhousedao/network-admin 0.0.64 → 1.0.0-dev.2

package/dist/document-models/workstream/src/tests/proposals-reducers.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Comprehensive tests for Proposals reducers
+ */
+export {};
+//# sourceMappingURL=proposals-reducers.test.d.ts.map

package/dist/document-models/workstream/src/tests/proposals-reducers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals-reducers.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/proposals-reducers.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/document-models/workstream/src/tests/proposals-reducers.test.js

@@ -0,0 +1,318 @@
+/**
+ * Comprehensive tests for Proposals reducers
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { generateMock } from "@powerhousedao/codegen";
+import utils from "../../gen/utils.js";
+import { z, } from "../../gen/schema/index.js";
+import { reducer } from "../../gen/reducer.js";
+import * as creators from "../../gen/proposals/creators.js";
+describe("Proposals Reducers - State Changes", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+    describe("editInitialProposal", () => {
+        it("should create initial proposal when it doesn't exist", () => {
+            const author = {
+                id: "author-123",
+                name: "John Doe",
+                icon: "https://example.com/avatar.jpg",
+            };
+            const input = {
+                id: "proposal-123",
+                sowId: "sow-456",
+                paymentTermsId: "terms-789",
+                status: "SUBMITTED",
+                proposalAuthor: author,
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal).toBeDefined();
+            expect(proposal.id).toBe("proposal-123");
+            expect(proposal.sow).toBe("sow-456");
+            expect(proposal.paymentTerms).toBe("terms-789");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe("John Doe");
+            expect(proposal.author.icon).toBe("https://example.com/avatar.jpg");
+        });
+        it("should update existing initial proposal", () => {
+            // First create initial proposal
+            const firstUpdate = reducer(document, creators.editInitialProposal({
+                id: "proposal-123",
+                status: "DRAFT",
+            }));
+            // Then update it
+            const input = {
+                id: "proposal-456",
+                sowId: "sow-789",
+                status: "SUBMITTED",
+                proposalAuthor: {
+                    id: "author-999",
+                    name: "Jane Smith",
+                },
+            };
+            const finalDocument = reducer(firstUpdate, creators.editInitialProposal(input));
+            const proposal = finalDocument.state.global.initialProposal;
+            expect(proposal.id).toBe("proposal-456");
+            expect(proposal.sow).toBe("sow-789");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("author-999");
+            expect(proposal.author.name).toBe("Jane Smith");
+        });
+        it("should handle optional fields correctly", () => {
+            const input = {
+                id: "proposal-123",
+                sowId: undefined,
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.id).toBe("proposal-123");
+            expect(proposal.sow).toBe(""); // Empty when undefined
+            expect(proposal.paymentTerms).toBe(""); // Empty when null
+            expect(proposal.status).toBe("DRAFT"); // Default when undefined
+        });
+        it("should handle empty string values", () => {
+            const input = {
+                id: "proposal-123",
+                sowId: "",
+                paymentTermsId: "",
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+        });
+        it("should handle author with null/undefined optional fields", () => {
+            const input = {
+                id: "proposal-123",
+                proposalAuthor: {
+                    id: "author-123",
+                    name: null,
+                    icon: undefined,
+                },
+            };
+            const updatedDocument = reducer(document, creators.editInitialProposal(input));
+            const proposal = updatedDocument.state.global.initialProposal;
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe(null);
+            expect(proposal.author.icon).toBe(null);
+        });
+    });
+    describe("addAlternativeProposal", () => {
+        it("should add new alternative proposal", () => {
+            const author = {
+                id: "author-123",
+                name: "Alternative Author",
+                icon: "https://example.com/alt-avatar.jpg",
+            };
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "sow-456",
+                paymentTermsId: "terms-789",
+                status: "DRAFT",
+                proposalAuthor: author,
+            };
+            const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(1);
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.id).toBe("alt-proposal-123");
+            expect(proposal.sow).toBe("sow-456");
+            expect(proposal.paymentTerms).toBe("terms-789");
+            expect(proposal.status).toBe("DRAFT");
+            expect(proposal.author.id).toBe("author-123");
+            expect(proposal.author.name).toBe("Alternative Author");
+            expect(proposal.author.icon).toBe("https://example.com/alt-avatar.jpg");
+        });
+        it("should add multiple alternative proposals", () => {
+            let currentDocument = document;
+            // Add first proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            // Add second proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-2",
+                status: "SUBMITTED",
+            }));
+            expect(currentDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(currentDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-1");
+            expect(currentDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-2");
+        });
+        it("should not add proposal if ID already exists", () => {
+            let currentDocument = document;
+            // Add proposal
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            // Try to add proposal with same ID
+            currentDocument = reducer(currentDocument, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "SUBMITTED",
+            }));
+            expect(currentDocument.state.global.alternativeProposals).toHaveLength(1);
+            expect(currentDocument.state.global.alternativeProposals[0].status).toBe("DRAFT"); // Unchanged
+        });
+        it("should handle optional fields with defaults", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: undefined,
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+            expect(proposal.status).toBe("DRAFT");
+            expect(proposal.author.id).toBe("");
+            expect(proposal.author.name).toBe(null);
+            expect(proposal.author.icon).toBe(null);
+        });
+    });
+    describe("editAlternativeProposal", () => {
+        beforeEach(() => {
+            // Add a proposal to edit
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-123",
+                sowId: "initial-sow",
+                status: "DRAFT",
+                proposalAuthor: {
+                    id: "initial-author",
+                    name: "Initial Author",
+                },
+            }));
+        });
+        it("should edit existing alternative proposal", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "updated-sow",
+                paymentTermsId: "updated-terms",
+                status: "SUBMITTED",
+                proposalAuthor: {
+                    id: "updated-author",
+                    name: "Updated Author",
+                    icon: "https://example.com/updated-avatar.jpg",
+                },
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("updated-sow");
+            expect(proposal.paymentTerms).toBe("updated-terms");
+            expect(proposal.status).toBe("SUBMITTED");
+            expect(proposal.author.id).toBe("updated-author");
+            expect(proposal.author.name).toBe("Updated Author");
+            expect(proposal.author.icon).toBe("https://example.com/updated-avatar.jpg");
+        });
+        it("should update only provided fields", () => {
+            const input = {
+                id: "alt-proposal-123",
+                status: "ACCEPTED",
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("initial-sow"); // Unchanged
+            expect(proposal.status).toBe("ACCEPTED"); // Changed
+            expect(proposal.author.name).toBe("Initial Author"); // Unchanged
+        });
+        it("should handle non-existent proposal ID gracefully", () => {
+            const input = {
+                id: "non-existent-proposal",
+                status: "SUBMITTED",
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            // Original proposal should remain unchanged
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.id).toBe("alt-proposal-123");
+            expect(proposal.status).toBe("DRAFT"); // Unchanged
+        });
+        it("should handle optional field updates", () => {
+            const input = {
+                id: "alt-proposal-123",
+                sowId: "",
+                paymentTermsId: null,
+                status: undefined,
+                proposalAuthor: undefined,
+            };
+            const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
+            const proposal = updatedDocument.state.global.alternativeProposals[0];
+            expect(proposal.sow).toBe("");
+            expect(proposal.paymentTerms).toBe("");
+            expect(proposal.status).toBe("DRAFT"); // Default when undefined
+        });
+    });
+    describe("removeAlternativeProposal", () => {
+        beforeEach(() => {
+            // Add multiple proposals to test removal
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-1",
+                status: "DRAFT",
+            }));
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-2",
+                status: "SUBMITTED",
+            }));
+            document = reducer(document, creators.addAlternativeProposal({
+                id: "alt-proposal-3",
+                status: "ACCEPTED",
+            }));
+        });
+        it("should remove existing alternative proposal", () => {
+            const input = {
+                id: "alt-proposal-2",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            const remainingIds = updatedDocument.state.global.alternativeProposals.map((p) => p.id);
+            expect(remainingIds).toContain("alt-proposal-1");
+            expect(remainingIds).toContain("alt-proposal-3");
+            expect(remainingIds).not.toContain("alt-proposal-2");
+        });
+        it("should handle removal of non-existent proposal gracefully", () => {
+            const input = {
+                id: "non-existent-proposal",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            // All original proposals should remain
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(3);
+            const remainingIds = updatedDocument.state.global.alternativeProposals.map((p) => p.id);
+            expect(remainingIds).toContain("alt-proposal-1");
+            expect(remainingIds).toContain("alt-proposal-2");
+            expect(remainingIds).toContain("alt-proposal-3");
+        });
+        it("should handle removal from empty array gracefully", () => {
+            // Start with empty document
+            const emptyDocument = utils.createDocument();
+            const input = {
+                id: "any-proposal",
+            };
+            const updatedDocument = reducer(emptyDocument, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(0);
+        });
+        it("should remove first proposal correctly", () => {
+            const input = {
+                id: "alt-proposal-1",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(updatedDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-2");
+            expect(updatedDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-3");
+        });
+        it("should remove last proposal correctly", () => {
+            const input = {
+                id: "alt-proposal-3",
+            };
+            const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
+            expect(updatedDocument.state.global.alternativeProposals).toHaveLength(2);
+            expect(updatedDocument.state.global.alternativeProposals[0].id).toBe("alt-proposal-1");
+            expect(updatedDocument.state.global.alternativeProposals[1].id).toBe("alt-proposal-2");
+        });
+    });
+});

package/dist/document-models/workstream/src/tests/proposals.test.js

@@ -2,48 +2,47 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { generateMock } from "@powerhousedao/codegen";
-import { reducer, utils, isWorkstreamDocument, editInitialProposal, EditInitialProposalInputSchema, addAlternativeProposal, AddAlternativeProposalInputSchema, editAlternativeProposal, EditAlternativeProposalInputSchema, removeAlternativeProposal, RemoveAlternativeProposalInputSchema, } from "@powerhousedao/network-admin/document-models/workstream";
+import utils from "../../gen/utils.js";
+import { z, } from "../../gen/schema/index.js";
+import { reducer } from "../../gen/reducer.js";
+import * as creators from "../../gen/proposals/creators.js";
 describe("Proposals Operations", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
     it("should handle editInitialProposal operation", () => {
-        const document = utils.createDocument();
-        const input = generateMock(EditInitialProposalInputSchema());
-        const updatedDocument = reducer(document, editInitialProposal(input));
-        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        const input = generateMock(z.EditInitialProposalInputSchema());
+        const updatedDocument = reducer(document, creators.editInitialProposal(input));
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_INITIAL_PROPOSAL");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].type).toBe("EDIT_INITIAL_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle addAlternativeProposal operation", () => {
-        const document = utils.createDocument();
-        const input = generateMock(AddAlternativeProposalInputSchema());
-        const updatedDocument = reducer(document, addAlternativeProposal(input));
-        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        const input = generateMock(z.AddAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.addAlternativeProposal(input));
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_ALTERNATIVE_PROPOSAL");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].type).toBe("ADD_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle editAlternativeProposal operation", () => {
-        const document = utils.createDocument();
-        const input = generateMock(EditAlternativeProposalInputSchema());
-        const updatedDocument = reducer(document, editAlternativeProposal(input));
-        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        const input = generateMock(z.EditAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.editAlternativeProposal(input));
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_ALTERNATIVE_PROPOSAL");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].type).toBe("EDIT_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle removeAlternativeProposal operation", () => {
-        const document = utils.createDocument();
-        const input = generateMock(RemoveAlternativeProposalInputSchema());
-        const updatedDocument = reducer(document, removeAlternativeProposal(input));
-        expect(isWorkstreamDocument(updatedDocument)).toBe(true);
+        const input = generateMock(z.RemoveAlternativeProposalInputSchema());
+        const updatedDocument = reducer(document, creators.removeAlternativeProposal(input));
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_ALTERNATIVE_PROPOSAL");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].type).toBe("REMOVE_ALTERNATIVE_PROPOSAL");
+        expect(updatedDocument.operations.global[0].input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
 });

package/dist/document-models/workstream/src/tests/workstream-reducers.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Comprehensive tests for Workstream reducers
+ */
+export {};
+//# sourceMappingURL=workstream-reducers.test.d.ts.map

package/dist/document-models/workstream/src/tests/workstream-reducers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workstream-reducers.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/workstream/src/tests/workstream-reducers.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/document-models/workstream/src/tests/workstream-reducers.test.js

@@ -0,0 +1,210 @@
+/**
+ * Comprehensive tests for Workstream reducers
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { generateMock } from "@powerhousedao/codegen";
+import utils from "../../gen/utils.js";
+import { z, } from "../../gen/schema/index.js";
+import { reducer } from "../../gen/reducer.js";
+import * as creators from "../../gen/workstream/creators.js";
+describe("Workstream Reducers - State Changes", () => {
+    let document;
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+    describe("editWorkstream", () => {
+        it("should update all workstream fields when provided", () => {
+            const input = {
+                code: "WS-001",
+                title: "Test Workstream",
+                status: "IN_PROGRESS",
+                sowId: "sow-123",
+                paymentTerms: "terms-456",
+            };
+            const updatedDocument = reducer(document, creators.editWorkstream(input));
+            expect(updatedDocument.state.global.code).toBe("WS-001");
+            expect(updatedDocument.state.global.title).toBe("Test Workstream");
+            expect(updatedDocument.state.global.status).toBe("IN_PROGRESS");
+            expect(updatedDocument.state.global.sow).toBe("sow-123");
+            expect(updatedDocument.state.global.paymentTerms).toBe("terms-456");
+        });
+        it("should update only provided fields, leaving others unchanged", () => {
+            // First set some initial values
+            const firstUpdate = reducer(document, creators.editWorkstream({
+                code: "WS-001",
+                title: "Initial Title",
+                status: "RFP_DRAFT",
+            }));
+            // Then update only some fields
+            const input = {
+                title: "Updated Title",
+                status: "OPEN_FOR_PROPOSALS",
+            };
+            const finalDocument = reducer(firstUpdate, creators.editWorkstream(input));
+            expect(finalDocument.state.global.code).toBe("WS-001"); // Unchanged
+            expect(finalDocument.state.global.title).toBe("Updated Title"); // Changed
+            expect(finalDocument.state.global.status).toBe("OPEN_FOR_PROPOSALS"); // Changed
+        });
+        it("should handle null/undefined values correctly", () => {
+            const input = {
+                code: undefined,
+                title: null,
+                status: "RFP_DRAFT",
+            };
+            const updatedDocument = reducer(document, creators.editWorkstream(input));
+            expect(updatedDocument.state.global.code).toBe(null); // Initial value
+            expect(updatedDocument.state.global.title).toBe(null);
+            expect(updatedDocument.state.global.status).toBe("RFP_DRAFT");
+        });
+        it("should handle empty string values by converting to null", () => {
+            const input = {
+                code: "",
+                title: "",
+            };
+            const updatedDocument = reducer(document, creators.editWorkstream(input));
+            expect(updatedDocument.state.global.code).toBe(null);
+            expect(updatedDocument.state.global.title).toBe(null);
+        });
+    });
+    describe("editClientInfo", () => {
+        it("should create client info when it doesn't exist", () => {
+            const input = {
+                clientId: "client-123",
+                name: "Test Client",
+                icon: "client-icon",
+            };
+            const updatedDocument = reducer(document, creators.editClientInfo(input));
+            expect(updatedDocument.state.global.client).toBeDefined();
+            expect(updatedDocument.state.global.client.id).toBe("client-123");
+            expect(updatedDocument.state.global.client.name).toBe("Test Client");
+            expect(updatedDocument.state.global.client.icon).toBe("client-icon");
+        });
+        it("should update existing client info", () => {
+            // First create client
+            const firstUpdate = reducer(document, creators.editClientInfo({
+                clientId: "client-123",
+                name: "Initial Name",
+            }));
+            // Then update client
+            const input = {
+                clientId: "client-456",
+                name: "Updated Name",
+                icon: "new-icon",
+            };
+            const finalDocument = reducer(firstUpdate, creators.editClientInfo(input));
+            expect(finalDocument.state.global.client.id).toBe("client-456");
+            expect(finalDocument.state.global.client.name).toBe("Updated Name");
+            expect(finalDocument.state.global.client.icon).toBe("new-icon");
+        });
+        it("should handle optional fields correctly", () => {
+            const input = {
+                clientId: "client-123",
+                name: undefined,
+                icon: null,
+            };
+            const updatedDocument = reducer(document, creators.editClientInfo(input));
+            expect(updatedDocument.state.global.client.id).toBe("client-123");
+            expect(updatedDocument.state.global.client.name).toBe(null);
+            expect(updatedDocument.state.global.client.icon).toBe(null);
+        });
+        it("should convert empty strings to null", () => {
+            const input = {
+                clientId: "client-123",
+                name: "",
+                icon: "",
+            };
+            const updatedDocument = reducer(document, creators.editClientInfo(input));
+            expect(updatedDocument.state.global.client.name).toBe(null);
+            expect(updatedDocument.state.global.client.icon).toBe(null);
+        });
+    });
+    describe("setRequestForProposal", () => {
+        it("should create RFP with provided values", () => {
+            const input = {
+                rfpId: "rfp-123",
+                title: "Test RFP Title",
+            };
+            const updatedDocument = reducer(document, creators.setRequestForProposal(input));
+            expect(updatedDocument.state.global.rfp).toBeDefined();
+            expect(updatedDocument.state.global.rfp.id).toBe("rfp-123");
+            expect(updatedDocument.state.global.rfp.title).toBe("Test RFP Title");
+        });
+        it("should replace existing RFP", () => {
+            // First create RFP
+            const firstUpdate = reducer(document, creators.setRequestForProposal({
+                rfpId: "rfp-123",
+                title: "Initial Title",
+            }));
+            // Then replace with new RFP
+            const input = {
+                rfpId: "rfp-456",
+                title: "New Title",
+            };
+            const finalDocument = reducer(firstUpdate, creators.setRequestForProposal(input));
+            expect(finalDocument.state.global.rfp.id).toBe("rfp-456");
+            expect(finalDocument.state.global.rfp.title).toBe("New Title");
+        });
+    });
+    describe("addPaymentRequest", () => {
+        it("should add payment request ID to empty array", () => {
+            const input = {
+                id: "payment-123",
+            };
+            const updatedDocument = reducer(document, creators.addPaymentRequest(input));
+            expect(updatedDocument.state.global.paymentRequests).toContain("payment-123");
+            expect(updatedDocument.state.global.paymentRequests).toHaveLength(1);
+        });
+        it("should add multiple payment request IDs", () => {
+            let currentDocument = document;
+            // Add first payment request
+            currentDocument = reducer(currentDocument, creators.addPaymentRequest({ id: "payment-123" }));
+            // Add second payment request
+            currentDocument = reducer(currentDocument, creators.addPaymentRequest({ id: "payment-456" }));
+            expect(currentDocument.state.global.paymentRequests).toContain("payment-123");
+            expect(currentDocument.state.global.paymentRequests).toContain("payment-456");
+            expect(currentDocument.state.global.paymentRequests).toHaveLength(2);
+        });
+        it("should not add duplicate payment request IDs", () => {
+            let currentDocument = document;
+            // Add payment request
+            currentDocument = reducer(currentDocument, creators.addPaymentRequest({ id: "payment-123" }));
+            // Try to add same payment request again
+            currentDocument = reducer(currentDocument, creators.addPaymentRequest({ id: "payment-123" }));
+            expect(currentDocument.state.global.paymentRequests).toHaveLength(1);
+            expect(currentDocument.state.global.paymentRequests[0]).toBe("payment-123");
+        });
+    });
+    describe("removePaymentRequest", () => {
+        it("should remove existing payment request ID", () => {
+            // First add some payment requests
+            let currentDocument = reducer(document, creators.addPaymentRequest({ id: "payment-123" }));
+            currentDocument = reducer(currentDocument, creators.addPaymentRequest({ id: "payment-456" }));
+            // Remove one payment request
+            const input = {
+                id: "payment-123",
+            };
+            const finalDocument = reducer(currentDocument, creators.removePaymentRequest(input));
+            expect(finalDocument.state.global.paymentRequests).not.toContain("payment-123");
+            expect(finalDocument.state.global.paymentRequests).toContain("payment-456");
+            expect(finalDocument.state.global.paymentRequests).toHaveLength(1);
+        });
+        it("should handle removal of non-existent payment request ID gracefully", () => {
+            // Add one payment request
+            const currentDocument = reducer(document, creators.addPaymentRequest({ id: "payment-123" }));
+            // Try to remove non-existent payment request
+            const input = {
+                id: "payment-999",
+            };
+            const finalDocument = reducer(currentDocument, creators.removePaymentRequest(input));
+            expect(finalDocument.state.global.paymentRequests).toContain("payment-123");
+            expect(finalDocument.state.global.paymentRequests).toHaveLength(1);
+        });
+        it("should handle removal from empty array gracefully", () => {
+            const input = {
+                id: "payment-123",
+            };
+            const updatedDocument = reducer(document, creators.removePaymentRequest(input));
+            expect(updatedDocument.state.global.paymentRequests).toHaveLength(0);
+        });
+    });
+});