Welcome to our survey
" }, + }, + questions: [ + { + id: "q1", + type: TSurveyQuestionTypeEnum.OpenText, + inputType: "text", + headline: { default: "What is your favorite color?" }, + required: true, + charLimit: { + enabled: false, + }, + }, + { + id: "q2", + type: TSurveyQuestionTypeEnum.OpenText, + inputType: "text", + headline: { default: "What is your favorite food?" }, + required: true, + charLimit: { + enabled: false, + }, + }, + { + id: "q3", + type: TSurveyQuestionTypeEnum.OpenText, + inputType: "text", + headline: { default: "What is your favorite movie?" }, + required: true, + charLimit: { + enabled: false, + }, + }, + { + id: "q4", + type: TSurveyQuestionTypeEnum.MultipleChoiceSingle, + headline: { default: "Select a number:" }, + choices: [ + { id: "mvedaklp0gxxycprpyhhwen7", label: { default: "lol" } }, + { id: "i7ws8uqyj66q5x086vbqtm8n", label: { default: "lmao" } }, + { id: "cy8hbbr9e2q6ywbfjbzwdsqn", label: { default: "XD" } }, + { id: "sojc5wwxc5gxrnuib30w7t6s", label: { default: "hehe" } }, + ], + required: true, + }, + { + id: "q5", + type: TSurveyQuestionTypeEnum.OpenText, + inputType: "number", + headline: { default: "Select your age group:" }, + required: true, + charLimit: { + enabled: false, + }, + }, + { + id: "q6", + type: TSurveyQuestionTypeEnum.MultipleChoiceMulti, + headline: { default: "Select your age group:" }, + required: true, + choices: [ + { id: "mvedaklp0gxxycprpyhhwen7", label: { default: "lol" } }, + { id: "i7ws8uqyj66q5x086vbqtm8n", label: { default: "lmao" } }, + { id: "cy8hbbr9e2q6ywbfjbzwdsqn", label: { default: "XD" } }, + { id: "sojc5wwxc5gxrnuib30w7t6s", label: { default: "hehe" } }, + ], + }, + ], + variables: [], + hiddenFields: { enabled: false, fieldIds: [] }, + endings: [], + displayOption: "respondMultiple" as const, + languages: [], + } as TSurveyCreateInput; + + const mockActionClasses = [ + { + id: "action-123", + createdAt: new Date(), + updatedAt: new Date(), + environmentId: mockEnvironmentId, + name: "Test Action", + description: "Test action description", + type: "code", + key: "test-action", + noCodeConfig: null, + }, + ]; + + beforeEach(() => { + vi.mocked(getActionClasses).mockResolvedValue(mockActionClasses as TActionClass[]); + }); + + describe("Happy Path", () => { + test("creates a survey successfully", async () => { + vi.mocked(getOrganizationByEnvironmentId).mockResolvedValueOnce(mockOrganizationOutput); + prisma.survey.create.mockResolvedValueOnce({ + ...mockSurveyOutput, + }); + + const result = await createSurvey(mockEnvironmentId, mockCreateSurveyInput); + + expect(prisma.survey.create).toHaveBeenCalled(); + expect(result.name).toEqual(mockSurveyOutput.name); + expect(subscribeOrganizationMembersToSurveyResponses).toHaveBeenCalled(); + expect(capturePosthogEnvironmentEvent).toHaveBeenCalled(); + }); + + test("creates a private segment for app surveys", async () => { + vi.mocked(getOrganizationByEnvironmentId).mockResolvedValueOnce(mockOrganizationOutput); + prisma.survey.create.mockResolvedValueOnce({ + ...mockSurveyOutput, + type: "app", + }); + + prisma.segment.create.mockResolvedValueOnce({ + id: "segment-123", + environmentId: mockEnvironmentId, + title: mockSurveyOutput.id, + isPrivate: true, + filters: [], + createdAt: new Date(), + updatedAt: new Date(), + } as unknown as TSegment); + + await createSurvey(mockEnvironmentId, { + ...mockCreateSurveyInput, + type: "app", + }); + + expect(prisma.segment.create).toHaveBeenCalled(); + expect(prisma.survey.update).toHaveBeenCalled(); + expect(segmentCache.revalidate).toHaveBeenCalled(); + }); + + test("creates survey with follow-ups", async () => { + vi.mocked(getOrganizationByEnvironmentId).mockResolvedValueOnce(mockOrganizationOutput); + const followUp = { + id: "followup1", + name: "Follow up 1", + trigger: { type: "response", properties: null }, + action: { + type: "send-email", + properties: { + to: "abc@example.com", + attachResponseData: true, + body: "Hello", + from: "hello@exmaple.com", + replyTo: ["hello@example.com"], + subject: "Follow up", + }, + }, + surveyId: mockSurveyOutput.id, + createdAt: new Date(), + updatedAt: new Date(), + } as TSurveyFollowUp; + + const surveyWithFollowUps = { + ...mockCreateSurveyInput, + followUps: [followUp], + }; + + prisma.survey.create.mockResolvedValueOnce({ + ...mockSurveyOutput, + }); + + await createSurvey(mockEnvironmentId, surveyWithFollowUps); + + expect(prisma.survey.create).toHaveBeenCalledWith( + expect.objectContaining({ + data: expect.objectContaining({ + followUps: { + create: [ + expect.objectContaining({ + name: "Follow up 1", + }), + ], + }, + }), + }) + ); + }); + }); + + describe("Sad Path", () => { + testInputValidation(createSurvey, "123#", mockCreateSurveyInput); + + test("throws ResourceNotFoundError if organization not found", async () => { + vi.mocked(getOrganizationByEnvironmentId).mockResolvedValueOnce(null); + await expect(createSurvey(mockEnvironmentId, mockCreateSurveyInput)).rejects.toThrow( + ResourceNotFoundError + ); + }); + + test("throws DatabaseError if there is a Prisma error", async () => { + vi.mocked(getOrganizationByEnvironmentId).mockResolvedValueOnce(mockOrganizationOutput); + const mockError = new Prisma.PrismaClientKnownRequestError("Database error", { + code: PrismaErrorType.UniqueConstraintViolation, + clientVersion: "1.0.0", + }); + prisma.survey.create.mockRejectedValueOnce(mockError); + + await expect(createSurvey(mockEnvironmentId, mockCreateSurveyInput)).rejects.toThrow(DatabaseError); + }); + }); +}); + +describe("Tests for getSurveyIdByResultShareKey", () => { + const mockResultShareKey = "share-key-123"; + + describe("Happy Path", () => { + test("returns survey ID when found", async () => { + prisma.survey.findFirst.mockResolvedValueOnce({ + id: mockId, + } as Survey); + + const result = await getSurveyIdByResultShareKey(mockResultShareKey); + + expect(prisma.survey.findFirst).toHaveBeenCalledWith({ + where: { resultShareKey: mockResultShareKey }, + select: { id: true }, + }); + expect(result).toBe(mockId); + }); + + test("returns null when survey not found", async () => { + prisma.survey.findFirst.mockResolvedValueOnce(null); + + const result = await getSurveyIdByResultShareKey(mockResultShareKey); + + expect(result).toBeNull(); + }); + }); + + describe("Sad Path", () => { + test("throws DatabaseError on Prisma error", async () => { + const mockError = new Prisma.PrismaClientKnownRequestError("Database error", { + code: PrismaErrorType.UniqueConstraintViolation, + clientVersion: "1.0.0", + }); + prisma.survey.findFirst.mockRejectedValueOnce(mockError); + + await expect(getSurveyIdByResultShareKey(mockResultShareKey)).rejects.toThrow(DatabaseError); + }); + + test("throws error on unexpected error", async () => { + prisma.survey.findFirst.mockRejectedValueOnce(new Error("Unexpected error")); + + await expect(getSurveyIdByResultShareKey(mockResultShareKey)).rejects.toThrow(Error); + }); + }); +}); + +describe("Tests for loadNewSegmentInSurvey", () => { + const mockSurveyId = mockId; + const mockNewSegmentId = "segment456"; + const mockCurrentSegmentId = "segment-123"; + const mockEnvironmentId = "env-123"; + + describe("Happy Path", () => { + test("loads new segment successfully", async () => { + // Set up mocks for existing survey + prisma.survey.findUnique.mockResolvedValueOnce({ + ...mockSurveyOutput, + }); + // Mock segment exists + prisma.segment.findUnique.mockResolvedValueOnce({ + id: mockNewSegmentId, + environmentId: mockEnvironmentId, + filters: [], + title: "Test Segment", + isPrivate: false, + createdAt: new Date(), + updatedAt: new Date(), + description: "Test Segment Description", + }); + // Mock survey update + prisma.survey.update.mockResolvedValueOnce({ + ...mockSurveyOutput, + segmentId: mockNewSegmentId, + }); + const result = await loadNewSegmentInSurvey(mockSurveyId, mockNewSegmentId); + expect(prisma.survey.update).toHaveBeenCalledWith({ + where: { id: mockSurveyId }, + data: { + segment: { + connect: { + id: mockNewSegmentId, + }, + }, + }, + select: expect.anything(), + }); + expect(result).toEqual( + expect.objectContaining({ + segmentId: mockNewSegmentId, + }) + ); + expect(surveyCache.revalidate).toHaveBeenCalledWith({ id: mockSurveyId }); + expect(segmentCache.revalidate).toHaveBeenCalledWith({ id: mockNewSegmentId }); + }); + + test("deletes private segment when changing to a new segment", async () => { + const mockSegment = { + id: mockCurrentSegmentId, + environmentId: mockEnvironmentId, + title: mockId, // Private segments have title = surveyId + isPrivate: true, + filters: [], + surveys: [mockSurveyId], + createdAt: new Date(), + updatedAt: new Date(), + description: "Test Segment Description", + }; + + // Set up mocks for existing survey with private segment + prisma.survey.findUnique.mockResolvedValueOnce({ + ...mockSurveyOutput, + segment: mockSegment, + } as Survey); + + // Mock segment exists + prisma.segment.findUnique.mockResolvedValueOnce({ + ...mockSegment, + id: mockNewSegmentId, + environmentId: mockEnvironmentId, + }); + + // Mock survey update + prisma.survey.update.mockResolvedValueOnce({ + ...mockSurveyOutput, + segment: { + id: mockNewSegmentId, + environmentId: mockEnvironmentId, + title: "Test Segment", + isPrivate: false, + filters: [], + surveys: [{ id: mockSurveyId }], + }, + } as Survey); + + // Mock segment delete + prisma.segment.delete.mockResolvedValueOnce({ + id: mockCurrentSegmentId, + environmentId: mockEnvironmentId, + surveys: [{ id: mockSurveyId }], + } as unknown as TSegment); + + await loadNewSegmentInSurvey(mockSurveyId, mockNewSegmentId); + + // Verify the private segment was deleted + expect(prisma.segment.delete).toHaveBeenCalledWith({ + where: { id: mockCurrentSegmentId }, + select: expect.anything(), + }); + // Verify the cache was invalidated + expect(segmentCache.revalidate).toHaveBeenCalledWith({ id: mockCurrentSegmentId }); + }); + }); + + describe("Sad Path", () => { + testInputValidation(loadNewSegmentInSurvey, "123#", "123#"); + + test("throws ResourceNotFoundError when survey not found", async () => { + prisma.survey.findUnique.mockResolvedValueOnce(null); + + await expect(loadNewSegmentInSurvey(mockSurveyId, mockNewSegmentId)).rejects.toThrow( + ResourceNotFoundError + ); + }); + + test("throws ResourceNotFoundError when segment not found", async () => { + // Set up mock for existing survey + prisma.survey.findUnique.mockResolvedValueOnce({ + ...mockSurveyOutput, + }); + + // Segment not found + prisma.segment.findUnique.mockResolvedValueOnce(null); + + await expect(loadNewSegmentInSurvey(mockSurveyId, mockNewSegmentId)).rejects.toThrow( + ResourceNotFoundError + ); + }); + + test("throws DatabaseError on Prisma error", async () => { + // Set up mock for existing survey + prisma.survey.findUnique.mockResolvedValueOnce({ + ...mockSurveyOutput, + }); + + // // Mock segment exists + prisma.segment.findUnique.mockResolvedValueOnce({ + id: mockNewSegmentId, + environmentId: mockEnvironmentId, + filters: [], + title: "Test Segment", + isPrivate: false, + createdAt: new Date(), + updatedAt: new Date(), + description: "Test Segment Description", + }); + + // Mock Prisma error on update + const mockError = new Prisma.PrismaClientKnownRequestError("Database error", { + code: PrismaErrorType.UniqueConstraintViolation, + clientVersion: "1.0.0", + }); + + prisma.survey.update.mockRejectedValueOnce(mockError); + + await expect(loadNewSegmentInSurvey(mockSurveyId, mockNewSegmentId)).rejects.toThrow(DatabaseError); + }); + }); +}); + +describe("Tests for getSurveysBySegmentId", () => { + const mockSegmentId = "segment-123"; + + describe("Happy Path", () => { + test("returns surveys associated with a segment", async () => { + prisma.survey.findMany.mockResolvedValueOnce([mockSurveyOutput]); + + const result = await getSurveysBySegmentId(mockSegmentId); + + expect(prisma.survey.findMany).toHaveBeenCalledWith({ + where: { segmentId: mockSegmentId }, + select: expect.anything(), + }); + + expect(result).toHaveLength(1); + expect(result[0]).toEqual( + expect.objectContaining({ + id: mockSurveyOutput.id, + }) + ); + }); + + test("returns empty array when no surveys found", async () => { + prisma.survey.findMany.mockResolvedValueOnce([]); + + const result = await getSurveysBySegmentId(mockSegmentId); + + expect(result).toEqual([]); + }); + }); + + describe("Sad Path", () => { + test("throws DatabaseError on Prisma error", async () => { + const mockError = new Prisma.PrismaClientKnownRequestError("Database error", { + code: PrismaErrorType.UniqueConstraintViolation, + clientVersion: "1.0.0", + }); + prisma.survey.findMany.mockRejectedValueOnce(mockError); + + await expect(getSurveysBySegmentId(mockSegmentId)).rejects.toThrow(DatabaseError); + }); + + test("throws error on unexpected error", async () => { + prisma.survey.findMany.mockRejectedValueOnce(new Error("Unexpected error")); + + await expect(getSurveysBySegmentId(mockSegmentId)).rejects.toThrow(Error); + }); + }); +}); diff --git a/apps/web/lib/survey/service.ts b/apps/web/lib/survey/service.ts index 155744d357..f440ba8d50 100644 --- a/apps/web/lib/survey/service.ts +++ b/apps/web/lib/survey/service.ts @@ -109,7 +109,7 @@ export const selectSurvey = { followUps: true, } satisfies Prisma.SurveySelect; -const checkTriggersValidity = (triggers: TSurvey["triggers"], actionClasses: ActionClass[]) => { +export const checkTriggersValidity = (triggers: TSurvey["triggers"], actionClasses: ActionClass[]) => { if (!triggers) return; // check if all the triggers are valid diff --git a/apps/web/lib/survey/tests/survey.test.ts b/apps/web/lib/survey/tests/survey.test.ts deleted file mode 100644 index 0fe4eb62e1..0000000000 --- a/apps/web/lib/survey/tests/survey.test.ts +++ /dev/null @@ -1,476 +0,0 @@ -import { prisma } from "@/lib/__mocks__/database"; -import { evaluateLogic } from "@/lib/surveyLogic/utils"; -import { Prisma } from "@prisma/client"; -import { beforeEach, describe, expect, test } from "vitest"; -import { testInputValidation } from "vitestSetup"; -import { PrismaErrorType } from "@formbricks/database/types/error"; -import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors"; -import { getSurvey, getSurveyCount, getSurveys, getSurveysByActionClassId, updateSurvey } from "../service"; -import { - mockActionClass, - mockId, - mockOrganizationOutput, - mockSurveyOutput, - mockSurveyWithLogic, - mockTransformedSurveyOutput, - updateSurveyInput, -} from "./__mock__/survey.mock"; - -beforeEach(() => { - prisma.survey.count.mockResolvedValue(1); -}); - -describe("evaluateLogic with mockSurveyWithLogic", () => { - test("should return true when q1 answer is blue", () => { - const data = { q1: "blue" }; - const variablesData = {}; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[0].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); - - test("should return false when q1 answer is not blue", () => { - const data = { q1: "red" }; - const variablesData = {}; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[0].logic![0].conditions, - "default" - ); - expect(result).toBe(false); - }); - - test("should return true when q1 is blue and q2 is pizza", () => { - const data = { q1: "blue", q2: "pizza" }; - const variablesData = {}; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[1].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); - - test("should return false when q1 is blue but q2 is not pizza", () => { - const data = { q1: "blue", q2: "burger" }; - const variablesData = {}; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[1].logic![0].conditions, - "default" - ); - expect(result).toBe(false); - }); - - test("should return true when q2 is pizza or q3 is Inception", () => { - const data = { q2: "pizza", q3: "Inception" }; - const variablesData = {}; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[2].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); - - test("should return true when var1 is equal to single select question value", () => { - const data = { q4: "lmao" }; - const variablesData = { siog1dabtpo3l0a3xoxw2922: "lmao" }; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[3].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); - - test("should return false when var1 is not equal to single select question value", () => { - const data = { q4: "lol" }; - const variablesData = { siog1dabtpo3l0a3xoxw2922: "damn" }; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[3].logic![0].conditions, - "default" - ); - expect(result).toBe(false); - }); - - test("should return true when var2 is greater than 30 and less than open text number value", () => { - const data = { q5: "40" }; - const variablesData = { km1srr55owtn2r7lkoh5ny1u: 35 }; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[4].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); - - test("should return false when var2 is not greater than 30 or greater than open text number value", () => { - const data = { q5: "40" }; - const variablesData = { km1srr55owtn2r7lkoh5ny1u: 25 }; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[4].logic![0].conditions, - "default" - ); - expect(result).toBe(false); - }); - - test("should return for complex condition", () => { - const data = { q6: ["lmao", "XD"], q1: "green", q2: "pizza", q3: "inspection", name: "pizza" }; - const variablesData = { siog1dabtpo3l0a3xoxw2922: "tokyo" }; - - const result = evaluateLogic( - mockSurveyWithLogic, - data, - variablesData, - mockSurveyWithLogic.questions[5].logic![0].conditions, - "default" - ); - expect(result).toBe(true); - }); -}); - -describe("Tests for getSurvey", () => { - describe("Happy Path", () => { - test("Returns a survey", async () => { - prisma.survey.findUnique.mockResolvedValueOnce(mockSurveyOutput); - const survey = await getSurvey(mockId); - expect(survey).toEqual(mockTransformedSurveyOutput); - }); - - test("Returns null if survey is not found", async () => { - prisma.survey.findUnique.mockResolvedValueOnce(null); - const survey = await getSurvey(mockId); - expect(survey).toBeNull(); - }); - }); - - describe("Sad Path", () => { - testInputValidation(getSurvey, "123#"); - - test("should throw a DatabaseError error if there is a PrismaClientKnownRequestError", async () => { - const mockErrorMessage = "Mock error message"; - const errToThrow = new Prisma.PrismaClientKnownRequestError(mockErrorMessage, { - code: PrismaErrorType.UniqueConstraintViolation, - clientVersion: "0.0.1", - }); - prisma.survey.findUnique.mockRejectedValue(errToThrow); - await expect(getSurvey(mockId)).rejects.toThrow(DatabaseError); - }); - - test("should throw an error if there is an unknown error", async () => { - const mockErrorMessage = "Mock error message"; - prisma.survey.findUnique.mockRejectedValue(new Error(mockErrorMessage)); - await expect(getSurvey(mockId)).rejects.toThrow(Error); - }); - }); -}); - -describe("Tests for getSurveysByActionClassId", () => { - describe("Happy Path", () => { - test("Returns an array of surveys for a given actionClassId", async () => { - prisma.survey.findMany.mockResolvedValueOnce([mockSurveyOutput]); - const surveys = await getSurveysByActionClassId(mockId); - expect(surveys).toEqual([mockTransformedSurveyOutput]); - }); - - test("Returns an empty array if no surveys are found", async () => { - prisma.survey.findMany.mockResolvedValueOnce([]); - const surveys = await getSurveysByActionClassId(mockId); - expect(surveys).toEqual([]); - }); - }); - - describe("Sad Path", () => { - testInputValidation(getSurveysByActionClassId, "123#"); - - test("should throw an error if there is an unknown error", async () => { - const mockErrorMessage = "Unknown error occurred"; - prisma.survey.findMany.mockRejectedValue(new Error(mockErrorMessage)); - await expect(getSurveysByActionClassId(mockId)).rejects.toThrow(Error); - }); - }); -}); - -describe("Tests for getSurveys", () => { - describe("Happy Path", () => { - test("Returns an array of surveys for a given environmentId, limit(optional) and offset(optional)", async () => { - prisma.survey.findMany.mockResolvedValueOnce([mockSurveyOutput]); - const surveys = await getSurveys(mockId); - expect(surveys).toEqual([mockTransformedSurveyOutput]); - }); - - test("Returns an empty array if no surveys are found", async () => { - prisma.survey.findMany.mockResolvedValueOnce([]); - - const surveys = await getSurveys(mockId); - expect(surveys).toEqual([]); - }); - }); - - describe("Sad Path", () => { - testInputValidation(getSurveysByActionClassId, "123#"); - - test("should throw a DatabaseError error if there is a PrismaClientKnownRequestError", async () => { - const mockErrorMessage = "Mock error message"; - const errToThrow = new Prisma.PrismaClientKnownRequestError(mockErrorMessage, { - code: PrismaErrorType.UniqueConstraintViolation, - clientVersion: "0.0.1", - }); - - prisma.survey.findMany.mockRejectedValue(errToThrow); - await expect(getSurveys(mockId)).rejects.toThrow(DatabaseError); - }); - - test("should throw an error if there is an unknown error", async () => { - const mockErrorMessage = "Unknown error occurred"; - prisma.survey.findMany.mockRejectedValue(new Error(mockErrorMessage)); - await expect(getSurveys(mockId)).rejects.toThrow(Error); - }); - }); -}); - -describe("Tests for updateSurvey", () => { - beforeEach(() => { - prisma.actionClass.findMany.mockResolvedValueOnce([mockActionClass]); - }); - describe("Happy Path", () => { - test("Updates a survey successfully", async () => { - prisma.survey.findUnique.mockResolvedValueOnce(mockSurveyOutput); - prisma.organization.findFirst.mockResolvedValueOnce(mockOrganizationOutput); - prisma.survey.update.mockResolvedValueOnce(mockSurveyOutput); - const updatedSurvey = await updateSurvey(updateSurveyInput); - expect(updatedSurvey).toEqual(mockTransformedSurveyOutput); - }); - }); - - describe("Sad Path", () => { - testInputValidation(updateSurvey, "123#"); - - test("Throws ResourceNotFoundError if the survey does not exist", async () => { - prisma.survey.findUnique.mockRejectedValueOnce( - new ResourceNotFoundError("Survey", updateSurveyInput.id) - ); - await expect(updateSurvey(updateSurveyInput)).rejects.toThrow(ResourceNotFoundError); - }); - - test("should throw a DatabaseError error if there is a PrismaClientKnownRequestError", async () => { - const mockErrorMessage = "Mock error message"; - const errToThrow = new Prisma.PrismaClientKnownRequestError(mockErrorMessage, { - code: PrismaErrorType.UniqueConstraintViolation, - clientVersion: "0.0.1", - }); - prisma.survey.findUnique.mockResolvedValueOnce(mockSurveyOutput); - prisma.organization.findFirst.mockResolvedValueOnce(mockOrganizationOutput); - prisma.survey.update.mockRejectedValue(errToThrow); - await expect(updateSurvey(updateSurveyInput)).rejects.toThrow(DatabaseError); - }); - - test("should throw an error if there is an unknown error", async () => { - const mockErrorMessage = "Unknown error occurred"; - prisma.survey.findUnique.mockResolvedValueOnce(mockSurveyOutput); - prisma.survey.update.mockRejectedValue(new Error(mockErrorMessage)); - await expect(updateSurvey(updateSurveyInput)).rejects.toThrow(Error); - }); - }); -}); - -// describe("Tests for createSurvey", () => { -// beforeEach(() => { -// prisma.actionClass.findMany.mockResolvedValueOnce([mockActionClass]); -// }); - -// describe("Happy Path", () => { -// test("Creates a survey successfully", async () => { -// prisma.survey.create.mockResolvedValueOnce(mockSurveyOutput); -// prisma.organization.findFirst.mockResolvedValueOnce(mockOrganizationOutput); -// prisma.actionClass.findMany.mockResolvedValue([mockActionClass]); -// prisma.user.findMany.mockResolvedValueOnce([ -// { -// ...mockUser, -// twoFactorSecret: null, -// backupCodes: null, -// password: null, -// identityProviderAccountId: null, -// groupId: null, -// role: "engineer", -// }, -// ]); -// prisma.user.update.mockResolvedValueOnce({ -// ...mockUser, -// twoFactorSecret: null, -// backupCodes: null, -// password: null, -// identityProviderAccountId: null, -// groupId: null, -// role: "engineer", -// }); -// const createdSurvey = await createSurvey(mockId, createSurveyInput); -// expect(createdSurvey).toEqual(mockTransformedSurveyOutput); -// }); -// }); - -// describe("Sad Path", () => { -// testInputValidation(createSurvey, "123#", createSurveyInput); - -// test("should throw an error if there is an unknown error", async () => { -// const mockErrorMessage = "Unknown error occurred"; -// prisma.survey.delete.mockRejectedValue(new Error(mockErrorMessage)); -// await expect(createSurvey(mockId, createSurveyInput)).rejects.toThrow(Error); -// }); -// }); -// }); - -// describe("Tests for duplicateSurvey", () => { -// beforeEach(() => { -// prisma.actionClass.findMany.mockResolvedValueOnce([mockActionClass]); -// }); - -// describe("Happy Path", () => { -// test("Duplicates a survey successfully", async () => { -// prisma.survey.findUnique.mockResolvedValueOnce(mockSurveyOutput); -// prisma.survey.create.mockResolvedValueOnce(mockSurveyOutput); -// // @ts-expect-error -// prisma.environment.findUnique.mockResolvedValueOnce(mockEnvironment); -// // @ts-expect-error -// prisma.project.findFirst.mockResolvedValueOnce(mockProject); -// prisma.actionClass.findFirst.mockResolvedValueOnce(mockActionClass); -// prisma.actionClass.create.mockResolvedValueOnce(mockActionClass); - -// const createdSurvey = await copySurveyToOtherEnvironment(mockId, mockId, mockId, mockId); -// expect(createdSurvey).toEqual(mockSurveyOutput); -// }); -// }); - -// describe("Sad Path", () => { -// testInputValidation(copySurveyToOtherEnvironment, "123#", "123#", "123#", "123#", "123#"); - -// test("Throws ResourceNotFoundError if the survey does not exist", async () => { -// prisma.survey.findUnique.mockRejectedValueOnce(new ResourceNotFoundError("Survey", mockId)); -// await expect(copySurveyToOtherEnvironment(mockId, mockId, mockId, mockId)).rejects.toThrow( -// ResourceNotFoundError -// ); -// }); - -// test("should throw an error if there is an unknown error", async () => { -// const mockErrorMessage = "Unknown error occurred"; -// prisma.survey.create.mockRejectedValue(new Error(mockErrorMessage)); -// await expect(copySurveyToOtherEnvironment(mockId, mockId, mockId, mockId)).rejects.toThrow(Error); -// }); -// }); -// }); - -// describe("Tests for getSyncSurveys", () => { -// describe("Happy Path", () => { -// beforeEach(() => { -// prisma.project.findFirst.mockResolvedValueOnce({ -// ...mockProject, -// brandColor: null, -// highlightBorderColor: null, -// logo: null, -// }); -// prisma.display.findMany.mockResolvedValueOnce([mockDisplay]); -// prisma.attributeClass.findMany.mockResolvedValueOnce([mockAttributeClass]); -// }); - -// test("Returns synced surveys", async () => { -// prisma.survey.findMany.mockResolvedValueOnce([mockSyncSurveyOutput]); -// prisma.person.findUnique.mockResolvedValueOnce(mockPrismaPerson); -// prisma.response.findMany.mockResolvedValue([mockResponseWithMockPerson]); -// prisma.responseNote.findMany.mockResolvedValue([mockResponseNote]); - -// const surveys = await getSyncSurveys(mockId, mockPrismaPerson.id, "desktop", { -// version: "1.7.0", -// }); -// expect(surveys).toEqual([mockTransformedSyncSurveyOutput]); -// }); - -// test("Returns an empty array if no surveys are found", async () => { -// prisma.survey.findMany.mockResolvedValueOnce([]); -// prisma.person.findUnique.mockResolvedValueOnce(mockPrismaPerson); -// const surveys = await getSyncSurveys(mockId, mockPrismaPerson.id, "desktop", { -// version: "1.7.0", -// }); -// expect(surveys).toEqual([]); -// }); -// }); - -// describe("Sad Path", () => { -// testInputValidation(getSyncSurveys, "123#", {}); - -// test("does not find a Project", async () => { -// prisma.project.findFirst.mockResolvedValueOnce(null); - -// await expect( -// getSyncSurveys(mockId, mockPrismaPerson.id, "desktop", { version: "1.7.0" }) -// ).rejects.toThrow(Error); -// }); - -// test("should throw an error if there is an unknown error", async () => { -// const mockErrorMessage = "Unknown error occurred"; -// prisma.actionClass.findMany.mockResolvedValueOnce([mockActionClass]); -// prisma.survey.create.mockRejectedValue(new Error(mockErrorMessage)); -// await expect( -// getSyncSurveys(mockId, mockPrismaPerson.id, "desktop", { version: "1.7.0" }) -// ).rejects.toThrow(Error); -// }); -// }); -// }); - -describe("Tests for getSurveyCount service", () => { - describe("Happy Path", () => { - test("Counts the total number of surveys for a given environment ID", async () => { - const count = await getSurveyCount(mockId); - expect(count).toEqual(1); - }); - - test("Returns zero count when there are no surveys for a given environment ID", async () => { - prisma.survey.count.mockResolvedValue(0); - const count = await getSurveyCount(mockId); - expect(count).toEqual(0); - }); - }); - - describe("Sad Path", () => { - testInputValidation(getSurveyCount, "123#"); - - test("Throws a generic Error for other unexpected issues", async () => { - const mockErrorMessage = "Mock error message"; - prisma.survey.count.mockRejectedValue(new Error(mockErrorMessage)); - - await expect(getSurveyCount(mockId)).rejects.toThrow(Error); - }); - }); -}); diff --git a/apps/web/lib/survey/utils.test.ts b/apps/web/lib/survey/utils.test.ts new file mode 100644 index 0000000000..18dee96bce --- /dev/null +++ b/apps/web/lib/survey/utils.test.ts @@ -0,0 +1,254 @@ +import * as fileValidation from "@/lib/fileValidation"; +import { beforeEach, describe, expect, test, vi } from "vitest"; +import { InvalidInputError } from "@formbricks/types/errors"; +import { TJsEnvironmentStateSurvey } from "@formbricks/types/js"; +import { TSegment } from "@formbricks/types/segment"; +import { TSurvey, TSurveyQuestion, TSurveyQuestionTypeEnum } from "@formbricks/types/surveys/types"; +import { anySurveyHasFilters, checkForInvalidImagesInQuestions, transformPrismaSurvey } from "./utils"; + +describe("transformPrismaSurvey", () => { + test("transforms prisma survey without segment", () => { + const surveyPrisma = { + id: "survey1", + name: "Test Survey", + displayPercentage: "30", + segment: null, + }; + + const result = transformPrismaSurvey(surveyPrisma); + + expect(result).toEqual({ + id: "survey1", + name: "Test Survey", + displayPercentage: 30, + segment: null, + }); + }); + + test("transforms prisma survey with segment", () => { + const surveyPrisma = { + id: "survey1", + name: "Test Survey", + displayPercentage: "50", + segment: { + id: "segment1", + name: "Test Segment", + filters: [{ id: "filter1", type: "user" }], + surveys: [{ id: "survey1" }, { id: "survey2" }], + }, + }; + + const result = transformPrismaSurvey