create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

package/templates/default/src/services/environment/environment-service.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it, vi } from 'vitest'
+import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import {
+  createEnvironment,
+  deleteEnvironments,
+  getEnvironmentByIdOrThrow,
+  listEnvironments,
+  updateEnvironment,
+} from './environment-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    environment: {
+      findUnique: vi.fn(),
+      findFirst: vi.fn(),
+      create: vi.fn(),
+      findMany: vi.fn(),
+      deleteMany: vi.fn(),
+      update: vi.fn(),
+    },
+  },
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    syncEnvironments: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+const basePayload = environmentSchema.parse({
+  name: 'Dev',
+  baseUrl: 'https://example.com',
+  apiBaseUrl: '',
+  username: '',
+  password: '',
+})
+
+describe('getEnvironmentByIdOrThrow', () => {
+  it('throws when environment is missing', async () => {
+    vi.mocked(prisma.environment.findUnique).mockResolvedValue(null)
+    await expect(getEnvironmentByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Environment not found',
+      statusCode: 404,
+    })
+  })
+})
+
+describe('createEnvironment', () => {
+  it('throws when name already exists', async () => {
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue({ id: 'e1' } as never)
+    await expect(createEnvironment(basePayload)).rejects.toMatchObject({
+      message: expect.stringContaining('already exists'),
+      statusCode: 400,
+    })
+    expect(prisma.environment.create).not.toHaveBeenCalled()
+  })
+
+  it('creates and returns environment when name is unique', async () => {
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue(null)
+    const created = { id: 'new-id', name: 'Dev' }
+    vi.mocked(prisma.environment.create).mockResolvedValue(created as never)
+
+    await expect(createEnvironment(basePayload)).resolves.toEqual(created)
+    expect(prisma.environment.create).toHaveBeenCalledWith({
+      data: {
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: null,
+        username: null,
+        password: null,
+      },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('listEnvironments', () => {
+  it('loads environments and syncs the projection file', async () => {
+    vi.mocked(prisma.environment.findMany).mockResolvedValue([{ id: 'env-1' }] as never)
+
+    await expect(listEnvironments()).resolves.toEqual([{ id: 'env-1' }])
+    expect(prisma.environment.findMany).toHaveBeenCalledWith({
+      orderBy: { createdAt: 'desc' },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('deleteEnvironments', () => {
+  it('deletes environments and syncs projection output', async () => {
+    vi.mocked(prisma.environment.deleteMany).mockResolvedValue({ count: 1 } as never)
+
+    await deleteEnvironments(['env-1'])
+
+    expect(prisma.environment.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['env-1'] } },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})
+
+describe('updateEnvironment', () => {
+  it('updates the environment, normalizes blank fields, and syncs projections', async () => {
+    vi.mocked(prisma.environment.findUnique)
+      .mockResolvedValueOnce({ name: 'Old Name' } as never)
+      .mockResolvedValueOnce({ id: 'env-1' } as never)
+    vi.mocked(prisma.environment.findFirst).mockResolvedValue(null)
+    vi.mocked(prisma.environment.update).mockResolvedValue({ id: 'env-1', name: 'Dev' } as never)
+
+    const result = await updateEnvironment(
+      'env-1',
+      environmentSchema.parse({
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: '',
+        username: '',
+        password: '',
+      }),
+    )
+
+    expect(result).toEqual({ id: 'env-1', name: 'Dev' })
+    expect(prisma.environment.update).toHaveBeenCalledWith({
+      where: { id: 'env-1' },
+      data: {
+        name: 'Dev',
+        baseUrl: 'https://example.com',
+        apiBaseUrl: null,
+        username: null,
+        password: null,
+      },
+    })
+    expect(automationProjectionService.syncEnvironments).toHaveBeenCalled()
+  })
+})

package/templates/default/src/services/environment/environment-service.ts

@@ -0,0 +1,96 @@
+import prisma from '@/config/db-config'
+import { environmentSchema } from '@/constants/form-opts/environment-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { ServiceError } from '@/services/shared/errors'
+import type { Environment } from '@prisma/client'
+import type { z } from 'zod'
+
+async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
+  const existing = await prisma.environment.findFirst({
+    where: {
+      name,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  })
+  return !!existing
+}
+
+function normalizeEnvironmentPayload(value: z.infer<typeof environmentSchema>) {
+  return {
+    ...value,
+    apiBaseUrl: value.apiBaseUrl === '' ? null : value.apiBaseUrl,
+    username: value.username === '' ? null : value.username,
+    password: value.password === '' ? null : value.password,
+  }
+}
+
+export async function listEnvironments(): Promise<Environment[]> {
+  const environments = await prisma.environment.findMany({
+    orderBy: { createdAt: 'desc' },
+  })
+  await automationProjectionService.syncEnvironments()
+  return environments
+}
+
+export async function deleteEnvironments(ids: string[]): Promise<void> {
+  await prisma.environment.deleteMany({ where: { id: { in: ids } } })
+  await automationProjectionService.syncEnvironments()
+}
+
+export async function createEnvironment(value: z.infer<typeof environmentSchema>): Promise<Environment> {
+  const nameExists = await checkUniqueName(value.name)
+  if (nameExists) {
+    throw new ServiceError(
+      'An environment with this name already exists. Please choose a different name.',
+      'VALIDATION',
+      400,
+    )
+  }
+  const newEnvironment = await prisma.environment.create({
+    data: normalizeEnvironmentPayload(value),
+  })
+  await automationProjectionService.syncEnvironments()
+  return newEnvironment
+}
+
+export async function getEnvironmentByIdOrThrow(id: string): Promise<Environment> {
+  const environmentData = await prisma.environment.findUnique({ where: { id } })
+  if (!environmentData) {
+    throw new ServiceError('Environment not found', 'NOT_FOUND', 404)
+  }
+  return environmentData
+}
+
+export async function updateEnvironment(
+  id: string | undefined,
+  value: z.infer<typeof environmentSchema>,
+): Promise<Environment> {
+  if (!id) {
+    throw new ServiceError('Environment id is required', 'VALIDATION', 400)
+  }
+  const currentEnvironment = await prisma.environment.findUnique({
+    where: { id },
+    select: { name: true },
+  })
+  if (!currentEnvironment) {
+    throw new ServiceError('Environment not found', 'NOT_FOUND', 404)
+  }
+
+  if (currentEnvironment.name !== value.name) {
+    const nameExists = await checkUniqueName(value.name, id)
+    if (nameExists) {
+      throw new ServiceError(
+        'An environment with this name already exists. Please choose a different name.',
+        'VALIDATION',
+        400,
+      )
+    }
+  }
+
+  const updatedEnvironment = await prisma.environment.update({
+    where: { id },
+    data: normalizeEnvironmentPayload(value),
+  })
+  await automationProjectionService.syncEnvironments()
+  return updatedEnvironment
+}

package/templates/default/src/services/locator/locator-path-utils.test.ts

@@ -0,0 +1,14 @@
+import path from 'path'
+import { describe, expect, it } from 'vitest'
+import { extractLocatorGroupName, extractModulePathFromLocatorFile } from './locator-path-utils'
+
+describe('locator-path-utils', () => {
+  it('extractLocatorGroupName strips json extension', () => {
+    expect(extractLocatorGroupName('g:\\app\\automation\\locators\\base\\Login.json')).toBe('Login')
+  })
+
+  it('extractModulePathFromLocatorFile returns root for file at locators root', () => {
+    const fileAtRoot = path.join(process.cwd(), 'automation', 'locators', 'Login.json')
+    expect(extractModulePathFromLocatorFile(fileAtRoot)).toBe('/')
+  })
+})

package/templates/default/src/services/locator/locator-path-utils.ts

@@ -0,0 +1,14 @@
+import { getAutomationLocatorsDir } from '@/lib/automation/automation-path-roots'
+import path from 'path'
+
+export function extractModulePathFromLocatorFile(filePath: string): string {
+  const locatorsDir = getAutomationLocatorsDir()
+  const relativePath = path.relative(locatorsDir, filePath)
+  const pathParts = relativePath.split(/[/\\]/).filter(part => part)
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
+}
+
+export function extractLocatorGroupName(filePath: string): string {
+  return path.basename(filePath.replace(/\\/g, '/'), '.json')
+}

package/templates/default/src/services/locator/locator-service.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { deleteLocators, detectAndCreateConflicts } from './locator-service'
+
+vi.mock('@/lib/locator-picker/session-manager', () => ({
+  locatorPickerSessionManager: {},
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    syncLocatorGroup: vi.fn().mockResolvedValue(undefined),
+    createEmptyLocatorGroup: vi.fn().mockResolvedValue(undefined),
+    syncLocatorMap: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    locator: {
+      findMany: vi.fn(),
+      findUnique: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      deleteMany: vi.fn(),
+      findFirst: vi.fn(),
+    },
+    conflictResolution: {
+      findFirst: vi.fn(),
+      create: vi.fn(),
+    },
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('detectAndCreateConflicts', () => {
+  it('returns 0 when no other locators in group', async () => {
+    vi.mocked(prisma.locator.findMany).mockResolvedValue([])
+
+    await expect(
+      detectAndCreateConflicts('loc-1', 'btn', '//x', 'group-1'),
+    ).resolves.toBe(0)
+    expect(prisma.conflictResolution.create).not.toHaveBeenCalled()
+  })
+})
+
+describe('deleteLocators', () => {
+  it('deletes locators and syncs the affected locator group files', async () => {
+    vi.mocked(prisma.locator.findMany).mockResolvedValue([
+      { locatorGroupId: 'group-1' },
+      { locatorGroupId: 'group-1' },
+      { locatorGroupId: 'group-2' },
+    ] as never)
+    vi.mocked(prisma.locator.deleteMany).mockResolvedValue({ count: 3 } as never)
+
+    await expect(deleteLocators(['loc-1', 'loc-2', 'loc-3'])).resolves.toEqual({ count: 3 })
+    expect(prisma.locator.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['loc-1', 'loc-2', 'loc-3'] } },
+    })
+    expect(automationProjectionService.syncLocatorGroup).toHaveBeenCalledWith('group-1')
+    expect(automationProjectionService.syncLocatorGroup).toHaveBeenCalledWith('group-2')
+  })
+})