refactor: unify import statements for consistency in test files

Author: Thavarshan

test/config/llm.test.ts

@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { EngineState } from "../../src/state";
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { EngineState } from '../../src/state';
 
 const completionsMock = vi.fn();
 
-vi.mock("openai", () => {
+vi.mock('openai', () => {
   return {
     default: vi.fn().mockImplementation(() => ({
       chat: {
@@ -15,55 +15,49 @@ vi.mock("openai", () => {
   };
 });
 
-const { OpenAIFeedbackClient } = await import("../../src/config/llm");
+const { OpenAIFeedbackClient } = await import('../../src/config/llm');
 
-describe("OpenAIFeedbackClient", () => {
+describe('OpenAIFeedbackClient', () => {
   const baseState: EngineState = {
-    sessionId: "llm-test",
-    uploadUrl: "https://example.com/file.wav",
+    sessionId: 'llm-test',
+    uploadUrl: 'https://example.com/file.wav',
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
     delete process.env.OPENAI_API_KEY;
   });
 
-  it("throws when API key missing", () => {
+  it('throws when API key missing', () => {
     expect(() => new OpenAIFeedbackClient()).toThrow(/OPENAI_API_KEY/);
   });
 
-  it("calls OpenAI chat completions and returns parsed payload", async () => {
-    process.env.OPENAI_API_KEY = "test-key";
+  it('calls OpenAI chat completions and returns parsed payload', async () => {
+    process.env.OPENAI_API_KEY = 'test-key';
 
     completionsMock.mockResolvedValueOnce({
       choices: [
         {
           message: {
             content: JSON.stringify({
-              feedbackText: "Solid balance.",
-              suggestions: [
-                "Ease 2kHz",
-                "Add saturation",
-                "Use multiband compression",
-              ],
+              feedbackText: 'Solid balance.',
+              suggestions: ['Ease 2kHz', 'Add saturation', 'Use multiband compression'],
             }),
           },
         },
       ],
     });
 
-    const client = new OpenAIFeedbackClient({ model: "gpt-test" });
+    const client = new OpenAIFeedbackClient({ model: 'gpt-test' });
     const response = await client.generateFeedback(baseState);
 
-    expect(response.feedbackText).toContain("Solid");
+    expect(response.feedbackText).toContain('Solid');
     expect(response.suggestions).toHaveLength(3);
-    expect(completionsMock).toHaveBeenCalledWith(
-      expect.objectContaining({ model: "gpt-test" }),
-    );
+    expect(completionsMock).toHaveBeenCalledWith(expect.objectContaining({ model: 'gpt-test' }));
   });
 
-  it("throws when OpenAI returns empty content", async () => {
-    process.env.OPENAI_API_KEY = "test-key";
+  it('throws when OpenAI returns empty content', async () => {
+    process.env.OPENAI_API_KEY = 'test-key';
 
     completionsMock.mockResolvedValueOnce({
       choices: [
@@ -79,14 +73,14 @@ describe("OpenAIFeedbackClient", () => {
     await expect(client.generateFeedback(baseState)).rejects.toThrow(/empty response/);
   });
 
-  it("throws when OpenAI returns invalid JSON", async () => {
-    process.env.OPENAI_API_KEY = "test-key";
+  it('throws when OpenAI returns invalid JSON', async () => {
+    process.env.OPENAI_API_KEY = 'test-key';
 
     completionsMock.mockResolvedValueOnce({
       choices: [
         {
           message: {
-            content: "not-json",
+            content: 'not-json',
           },
         },
       ],
@@ -96,8 +90,8 @@ describe("OpenAIFeedbackClient", () => {
     await expect(client.generateFeedback(baseState)).rejects.toThrow(/Failed to parse/);
   });
 
-  it("throws when OpenAI omits content", async () => {
-    process.env.OPENAI_API_KEY = "test-key";
+  it('throws when OpenAI omits content', async () => {
+    process.env.OPENAI_API_KEY = 'test-key';
 
     completionsMock.mockResolvedValueOnce({
       choices: [

test/graph/auralyze-graph.unit.test.ts

@@ -201,18 +201,14 @@ describe('Auralyze LangGraph', () => {
     it('metadata step short-circuits when upload is missing or state errored', async () => {
       const metadataClient = { getMetadata: vi.fn() };
 
-      const missingUpload = await metadataStepNode(
-        { audioMetadataClient: metadataClient },
-        { sessionId: 'missing-upload' } as EngineState,
-      );
-      const upstreamError = await metadataStepNode(
-        { audioMetadataClient: metadataClient },
-        {
-          sessionId: 'errored',
-          uploadUrl: 'https://example.com/file.wav',
-          error: 'metadata blocked',
-        } as EngineState,
-      );
+      const missingUpload = await metadataStepNode({ audioMetadataClient: metadataClient }, {
+        sessionId: 'missing-upload',
+      } as EngineState);
+      const upstreamError = await metadataStepNode({ audioMetadataClient: metadataClient }, {
+        sessionId: 'errored',
+        uploadUrl: 'https://example.com/file.wav',
+        error: 'metadata blocked',
+      } as EngineState);
 
       expect(missingUpload).toEqual({});
       expect(upstreamError).toEqual({});
@@ -222,18 +218,14 @@ describe('Auralyze LangGraph', () => {
     it('analysis step short-circuits when upload missing or error set', async () => {
       const analysisClient = { analyze: vi.fn() };
 
-      const missingUpload = await analysisStepNode(
-        { audioAnalysisClient: analysisClient },
-        { sessionId: 'missing-upload' } as EngineState,
-      );
-      const upstreamError = await analysisStepNode(
-        { audioAnalysisClient: analysisClient },
-        {
-          sessionId: 'errored',
-          uploadUrl: 'https://example.com/file.wav',
-          error: 'analysis blocked',
-        } as EngineState,
-      );
+      const missingUpload = await analysisStepNode({ audioAnalysisClient: analysisClient }, {
+        sessionId: 'missing-upload',
+      } as EngineState);
+      const upstreamError = await analysisStepNode({ audioAnalysisClient: analysisClient }, {
+        sessionId: 'errored',
+        uploadUrl: 'https://example.com/file.wav',
+        error: 'analysis blocked',
+      } as EngineState);
 
       expect(missingUpload).toEqual({});
       expect(upstreamError).toEqual({});
@@ -243,14 +235,11 @@ describe('Auralyze LangGraph', () => {
     it('feedback step ignores execution when error present', async () => {
       const feedbackClient = { generateFeedback: vi.fn() };
 
-      const result = await feedbackStepNode(
-        { feedbackClient },
-        {
-          sessionId: 'errored',
-          uploadUrl: 'https://example.com/file.wav',
-          error: 'halt',
-        } as EngineState,
-      );
+      const result = await feedbackStepNode({ feedbackClient }, {
+        sessionId: 'errored',
+        uploadUrl: 'https://example.com/file.wav',
+        error: 'halt',
+      } as EngineState);
 
       expect(result).toEqual({});
       expect(feedbackClient.generateFeedback).not.toHaveBeenCalled();

test/tools.test.ts

@@ -8,10 +8,7 @@ import {
   createAudioAnalysisTool,
 } from '../src/tools/audio-analysis-tool';
 import { type EngineState } from '../src/state';
-import {
-  type FeedbackClient,
-  type FeedbackResult,
-} from '../src/tools/llm-feedback-tool';
+import { type FeedbackClient, type FeedbackResult } from '../src/tools/llm-feedback-tool';
 
 describe('audio-metadata-tool', () => {
   it('validates metadata schema', () => {