create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/blank/src/services/tag/tag-service.test.ts

@@ -1,16 +1,41 @@
-import { describe, expect, it, vi } from 'vitest'
-import { getTagByIdOrThrow } from './tag-service'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { tagSchema } from '@/constants/form-opts/tag-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { createTag, getTagByIdOrThrow, updateTag } from './tag-service'
 
 vi.mock('@/config/db-config', () => ({
   default: {
     tag: {
+      findFirst: vi.fn(),
       findUnique: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
     },
   },
 }))
 
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    regenerateAllFeatures: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
 import prisma from '@/config/db-config'
 
+const basePayload = tagSchema.parse({
+  name: 'Smoke',
+  tagExpression: '@smoke',
+})
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  vi.mocked(prisma.tag.findFirst).mockReset()
+  vi.mocked(prisma.tag.findUnique).mockReset()
+  vi.mocked(prisma.tag.create).mockReset()
+  vi.mocked(prisma.tag.update).mockReset()
+  vi.mocked(automationProjectionService.regenerateAllFeatures).mockResolvedValue(undefined)
+})
+
 describe('getTagByIdOrThrow', () => {
   it('throws when tag missing', async () => {
     vi.mocked(prisma.tag.findUnique).mockResolvedValue(null)
@@ -20,3 +45,116 @@ describe('getTagByIdOrThrow', () => {
     })
   })
 })
+
+describe('createTag', () => {
+  it('throws when tag name already exists', async () => {
+    vi.mocked(prisma.tag.findFirst).mockResolvedValueOnce({ id: 'tag-1' } as never)
+
+    await expect(createTag(basePayload)).rejects.toMatchObject({
+      message: expect.stringContaining('tag name'),
+      statusCode: 400,
+    })
+
+    expect(prisma.tag.create).not.toHaveBeenCalled()
+  })
+
+  it('throws when tag expression already exists', async () => {
+    vi.mocked(prisma.tag.findFirst)
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce({ id: 'tag-1' } as never)
+
+    await expect(createTag(basePayload)).rejects.toMatchObject({
+      message: expect.stringContaining('tag expression'),
+      statusCode: 400,
+    })
+
+    expect(prisma.tag.create).not.toHaveBeenCalled()
+  })
+
+  it('creates and returns a tag when tag expression is unique', async () => {
+    const created = { id: 'tag-2', name: 'Smoke', tagExpression: '@smoke' }
+
+    vi.mocked(prisma.tag.findFirst).mockResolvedValue(null)
+    vi.mocked(prisma.tag.create).mockResolvedValue(created as never)
+
+    await expect(createTag(basePayload)).resolves.toEqual(created)
+    expect(prisma.tag.create).toHaveBeenCalledWith({ data: basePayload })
+    expect(automationProjectionService.regenerateAllFeatures).toHaveBeenCalled()
+  })
+})
+
+describe('updateTag', () => {
+  it('throws when tag name already exists on another tag', async () => {
+    vi.mocked(prisma.tag.findUnique).mockResolvedValue({ name: 'Old Smoke', tagExpression: '@old-smoke' } as never)
+    vi.mocked(prisma.tag.findFirst).mockResolvedValueOnce({ id: 'tag-2' } as never)
+
+    await expect(
+      updateTag(
+        'tag-1',
+        tagSchema.parse({
+          name: 'Regression',
+          tagExpression: '@old-smoke',
+        }),
+      ),
+    ).rejects.toMatchObject({
+      message: expect.stringContaining('tag name'),
+      statusCode: 400,
+    })
+
+    expect(prisma.tag.update).not.toHaveBeenCalled()
+  })
+
+  it('throws when tag expression already exists on another tag', async () => {
+    vi.mocked(prisma.tag.findUnique).mockResolvedValue({ name: 'Smoke', tagExpression: '@old-smoke' } as never)
+    vi.mocked(prisma.tag.findFirst).mockResolvedValueOnce({ id: 'tag-2' } as never)
+
+    await expect(
+      updateTag(
+        'tag-1',
+        tagSchema.parse({
+          name: 'Smoke',
+          tagExpression: '@regression',
+        }),
+      ),
+    ).rejects.toMatchObject({
+      message: expect.stringContaining('tag expression'),
+      statusCode: 400,
+    })
+
+    expect(prisma.tag.update).not.toHaveBeenCalled()
+  })
+
+  it('updates the tag when the tag expression remains unchanged', async () => {
+    const updated = { id: 'tag-1', name: 'Smoke Updated', tagExpression: '@smoke' }
+
+    vi.mocked(prisma.tag.findUnique).mockResolvedValue({ name: 'Smoke', tagExpression: '@smoke' } as never)
+    vi.mocked(prisma.tag.findFirst).mockResolvedValueOnce(null)
+    vi.mocked(prisma.tag.update).mockResolvedValue(updated as never)
+
+    await expect(
+      updateTag(
+        'tag-1',
+        tagSchema.parse({
+          name: 'Smoke Updated',
+          tagExpression: '@smoke',
+        }),
+      ),
+    ).resolves.toEqual(updated)
+
+    expect(prisma.tag.findFirst).toHaveBeenCalledTimes(1)
+    expect(prisma.tag.findFirst).toHaveBeenCalledWith({
+      where: {
+        name: 'Smoke Updated',
+        id: { not: 'tag-1' },
+      },
+    })
+    expect(prisma.tag.update).toHaveBeenCalledWith({
+      where: { id: 'tag-1' },
+      data: {
+        name: 'Smoke Updated',
+        tagExpression: '@smoke',
+      },
+    })
+    expect(automationProjectionService.regenerateAllFeatures).toHaveBeenCalled()
+  })
+})

package/templates/blank/src/services/tag/tag-service.ts

@@ -6,6 +6,28 @@ import { TagType } from '@prisma/client'
 import type { Tag } from '@prisma/client'
 import type { z } from 'zod'
 
+async function checkUniqueTagName(name: string, excludeId?: string): Promise<boolean> {
+  const existing = await prisma.tag.findFirst({
+    where: {
+      name,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  })
+
+  return !!existing
+}
+
+async function checkUniqueTagExpression(tagExpression: string, excludeId?: string): Promise<boolean> {
+  const existing = await prisma.tag.findFirst({
+    where: {
+      tagExpression,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  })
+
+  return !!existing
+}
+
 export async function listFilterTags(): Promise<Tag[]> {
   return prisma.tag.findMany({
     where: { type: TagType.FILTER },
@@ -18,6 +40,24 @@ export async function deleteTags(ids: string[]): Promise<void> {
 }
 
 export async function createTag(value: z.infer<typeof tagSchema>): Promise<Tag> {
+  const tagNameExists = await checkUniqueTagName(value.name)
+  if (tagNameExists) {
+    throw new ServiceError(
+      'A tag with this name already exists. Please choose a different tag name.',
+      'VALIDATION',
+      400,
+    )
+  }
+
+  const tagExpressionExists = await checkUniqueTagExpression(value.tagExpression)
+  if (tagExpressionExists) {
+    throw new ServiceError(
+      'A tag with this tag expression already exists. Please choose a different tag expression.',
+      'VALIDATION',
+      400,
+    )
+  }
+
   const newTag = await prisma.tag.create({ data: value })
   await automationProjectionService.regenerateAllFeatures()
   return newTag
@@ -35,6 +75,37 @@ export async function updateTag(id: string | undefined, value: z.infer<typeof ta
   if (!id) {
     throw new ServiceError('Tag id is required', 'VALIDATION', 400)
   }
+
+  const currentTag = await prisma.tag.findUnique({
+    where: { id },
+    select: { name: true, tagExpression: true },
+  })
+  if (!currentTag) {
+    throw new ServiceError('Tag not found', 'NOT_FOUND', 404)
+  }
+
+  if (currentTag.name !== value.name) {
+    const tagNameExists = await checkUniqueTagName(value.name, id)
+    if (tagNameExists) {
+      throw new ServiceError(
+        'A tag with this name already exists. Please choose a different tag name.',
+        'VALIDATION',
+        400,
+      )
+    }
+  }
+
+  if (currentTag.tagExpression !== value.tagExpression) {
+    const tagExpressionExists = await checkUniqueTagExpression(value.tagExpression, id)
+    if (tagExpressionExists) {
+      throw new ServiceError(
+        'A tag with this tag expression already exists. Please choose a different tag expression.',
+        'VALIDATION',
+        400,
+      )
+    }
+  }
+
   const updatedTag = await prisma.tag.update({ where: { id }, data: value })
   await automationProjectionService.regenerateAllFeatures()
   return updatedTag

package/templates/blank/src/services/template-test-case/template-test-case-service.ts

@@ -11,9 +11,15 @@ const templateTestCaseInclude = {
       parameters: true,
     },
   },
+  flowBlocks: {
+    include: {
+      nodes: true,
+    },
+  },
 } as const
 
 export type TemplateTestCaseDetail = Prisma.TemplateTestCaseGetPayload<{ include: typeof templateTestCaseInclude }>
+type TemplateTestCaseInput = z.input<typeof templateTestCaseSchema>
 
 export async function listTemplateTestCases() {
   return prisma.templateTestCase.findMany({
@@ -33,11 +39,14 @@ export async function deleteTemplateTestCases(ids: string[]): Promise<void> {
     await tx.templateTestCaseStep.deleteMany({
       where: { templateTestCaseId: { in: ids } },
     })
+    await tx.templateTestCaseFlowBlock.deleteMany({
+      where: { templateTestCaseId: { in: ids } },
+    })
     await tx.templateTestCase.deleteMany({ where: { id: { in: ids } } })
   })
 }
 
-export async function createTemplateTestCase(value: z.infer<typeof templateTestCaseSchema>): Promise<TemplateTestCase> {
+export async function createTemplateTestCase(value: TemplateTestCaseInput): Promise<TemplateTestCase> {
   return prisma.templateTestCase.create({
     data: {
       name: value.title,
@@ -45,6 +54,7 @@ export async function createTemplateTestCase(value: z.infer<typeof templateTestC
       steps: {
         create: value.steps.map(step => ({
           gherkinStep: step.gherkinStep,
+          flowNodeId: step.nodeId,
           label: step.label,
           icon: step.icon,
           parameters: {
@@ -59,6 +69,16 @@ export async function createTemplateTestCase(value: z.infer<typeof templateTestC
           order: step.order,
         })),
       },
+      flowBlocks: {
+        create: (value.flowBlocks ?? []).map((block, index) => ({
+          id: block.id,
+          name: block.name,
+          order: index,
+          nodes: {
+            create: block.nodeIds.map(nodeId => ({ flowNodeId: nodeId })),
+          },
+        })),
+      },
     },
   })
 }
@@ -76,7 +96,7 @@ export async function getTemplateTestCaseByIdOrThrow(id: string): Promise<Templa
 
 export async function updateTemplateTestCase(
   id: string | undefined,
-  value: z.infer<typeof templateTestCaseSchema>,
+  value: TemplateTestCaseInput,
 ): Promise<TemplateTestCase> {
   if (!id) {
     throw new ServiceError(
@@ -99,6 +119,7 @@ export async function updateTemplateTestCase(
   }
 
   await prisma.templateTestCaseStep.deleteMany({ where: { templateTestCaseId: id } })
+  await prisma.templateTestCaseFlowBlock.deleteMany({ where: { templateTestCaseId: id } })
 
   return prisma.templateTestCase.update({
     where: { id },
@@ -108,6 +129,7 @@ export async function updateTemplateTestCase(
       steps: {
         create: value.steps.map(step => ({
           gherkinStep: step.gherkinStep,
+          flowNodeId: step.nodeId,
           label: step.label ?? '',
           icon: step.icon ?? '',
           parameters: {
@@ -122,6 +144,16 @@ export async function updateTemplateTestCase(
           order: step.order,
         })),
       },
+      flowBlocks: {
+        create: (value.flowBlocks ?? []).map((block, index) => ({
+          id: block.id,
+          name: block.name,
+          order: index,
+          nodes: {
+            create: block.nodeIds.map(nodeId => ({ flowNodeId: nodeId })),
+          },
+        })),
+      },
     },
     include: { steps: true },
   })

package/templates/blank/src/services/test-case/test-case-service.test.ts

@@ -10,6 +10,7 @@ vi.mock('@/config/db-config', () => ({
     testCase: { create: vi.fn(), findUnique: vi.fn(), update: vi.fn() },
     testCaseStep: { findMany: vi.fn(), deleteMany: vi.fn() },
     testCaseStepParameter: { deleteMany: vi.fn() },
+    testCaseFlowBlock: { deleteMany: vi.fn() },
   },
 }))
 

package/templates/blank/src/services/test-case/test-case-service.ts

@@ -101,13 +101,20 @@ export async function listTestCases() {
           parameters: true,
         },
       },
+      flowBlocks: {
+        include: {
+          nodes: true,
+        },
+      },
       TestSuite: true,
       tags: true,
     },
   })
 }
 
-export async function createTestCaseFromInput(value: z.infer<typeof testCaseSchema>) {
+type TestCaseInput = z.input<typeof testCaseSchema>
+
+export async function createTestCaseFromInput(value: TestCaseInput) {
   const uniqueTestCaseIdentifier = generateUniqueTestCaseIdentifier()
   const testCaseIdentifierTag = await prisma.tag.create({
     data: {
@@ -126,6 +133,7 @@ export async function createTestCaseFromInput(value: z.infer<typeof testCaseSche
     steps: {
       create: value.steps.map(step => ({
         gherkinStep: step.gherkinStep,
+        flowNodeId: step.nodeId,
         label: step.label,
         icon: step.icon,
         parameters: {
@@ -140,6 +148,16 @@ export async function createTestCaseFromInput(value: z.infer<typeof testCaseSche
         order: step.order,
       })),
     },
+    flowBlocks: {
+      create: (value.flowBlocks ?? []).map((block, index) => ({
+        id: block.id,
+        name: block.name,
+        order: index,
+        nodes: {
+          create: block.nodeIds.map(nodeId => ({ flowNodeId: nodeId })),
+        },
+      })),
+    },
   }
 
   const data =
@@ -182,6 +200,11 @@ export async function getTestCaseByIdOrThrow(id: string) {
           parameters: true,
         },
       },
+      flowBlocks: {
+        include: {
+          nodes: true,
+        },
+      },
       TestSuite: {
         select: {
           id: true,
@@ -209,7 +232,7 @@ export async function getTestCaseByIdOrThrow(id: string) {
   }
 }
 
-export async function updateTestCaseFromInput(value: z.infer<typeof testCaseSchema>, id: string) {
+export async function updateTestCaseFromInput(value: TestCaseInput, id: string) {
   const affectedTestSuites = await prisma.testSuite.findMany({
     where: {
       testCases: {
@@ -238,6 +261,9 @@ export async function updateTestCaseFromInput(value: z.infer<typeof testCaseSche
   await prisma.testCaseStep.deleteMany({
     where: { testCaseId: id },
   })
+  await prisma.testCaseFlowBlock.deleteMany({
+    where: { testCaseId: id },
+  })
 
   const existingTestCase = await prisma.testCase.findUnique({
     where: { id },
@@ -272,6 +298,7 @@ export async function updateTestCaseFromInput(value: z.infer<typeof testCaseSche
       steps: {
         create: value.steps.map(step => ({
           gherkinStep: step.gherkinStep,
+          flowNodeId: step.nodeId,
           label: step.label ?? '',
           icon: step.icon ?? '',
           parameters: {
@@ -286,6 +313,16 @@ export async function updateTestCaseFromInput(value: z.infer<typeof testCaseSche
           order: step.order,
         })),
       },
+      flowBlocks: {
+        create: (value.flowBlocks ?? []).map((block, index) => ({
+          id: block.id,
+          name: block.name,
+          order: index,
+          nodes: {
+            create: block.nodeIds.map(nodeId => ({ flowNodeId: nodeId })),
+          },
+        })),
+      },
     },
     include: {
       steps: true,