test(copilot): add unit tests for SessionManager and copilot utilities

ysfscream · ysfscream · commit a2397da2d767 · 2025-03-11T12:06:13.000+08:00
diff --git a/tests/unit/utils/ai/SessionManager.spec.ts b/tests/unit/utils/ai/SessionManager.spec.ts
@@ -0,0 +1,170 @@
+import { expect } from 'chai'
+import { SessionManager } from '@/utils/ai/SessionManager'
+
+describe('SessionManager', () => {
+  let sessionManager: SessionManager
+
+  beforeEach(() => {
+    // Create a new SessionManager instance before each test
+    sessionManager = new SessionManager()
+  })
+
+  describe('getState', () => {
+    it('should return a copy of the state', () => {
+      const state = sessionManager.getState()
+
+      // Verify that it returns an object
+      expect(state).to.be.an('object')
+
+      // Verify that the returned state contains expected properties
+      expect(state).to.have.property('systemPrompt')
+      expect(state).to.have.property('isNewSession')
+      expect(state).to.have.property('presetPrompt')
+
+      // Modifying the returned state should not affect the original state
+      state.isNewSession = false
+      expect(sessionManager.getState().isNewSession).to.be.true
+    })
+  })
+
+  describe('resetSession', () => {
+    it('should reset the session to initial values', () => {
+      // First modify the session state
+      sessionManager.startSession()
+      sessionManager.updatePreset('test-preset')
+
+      // Then reset
+      sessionManager.resetSession()
+
+      // Verify the state has been reset
+      const state = sessionManager.getState()
+      expect(state.isNewSession).to.be.true
+      expect(state.systemPrompt).to.equal('')
+      expect(state.presetPrompt).to.equal('')
+    })
+  })
+
+  describe('resetSessionKeepPreset', () => {
+    it('should reset the session while keeping preset prompt', () => {
+      // First modify the session state
+      sessionManager.startSession()
+      sessionManager.updatePreset('test-preset')
+
+      // Then reset, but keep the preset prompt
+      sessionManager.resetSessionKeepPreset()
+
+      // Verify the state has been reset, but preset prompt is retained
+      const state = sessionManager.getState()
+      expect(state.isNewSession).to.be.true
+      expect(state.systemPrompt).to.equal('')
+      expect(state.presetPrompt).to.equal('test-preset')
+    })
+  })
+
+  describe('startSession', () => {
+    it('should mark the session as not new', () => {
+      // Initially isNewSession should be true
+      expect(sessionManager.getState().isNewSession).to.be.true
+
+      // Start the session
+      sessionManager.startSession()
+
+      // Verify isNewSession becomes false
+      expect(sessionManager.getState().isNewSession).to.be.false
+    })
+
+    it('should not affect other state properties', () => {
+      // Set some initial state
+      sessionManager.updatePreset('test-preset')
+
+      // Record the current system prompt state
+      const initialSystemPrompt = sessionManager.getState().systemPrompt
+
+      // Start the session
+      sessionManager.startSession()
+
+      // Verify only the isNewSession property was modified
+      const state = sessionManager.getState()
+      expect(state.systemPrompt).to.equal(initialSystemPrompt)
+      expect(state.presetPrompt).to.equal('test-preset')
+    })
+  })
+
+  describe('updatePreset', () => {
+    it('should update the preset prompt', () => {
+      sessionManager.updatePreset('new-preset')
+
+      expect(sessionManager.getState().presetPrompt).to.equal('new-preset')
+    })
+
+    it('should mark the session as new', () => {
+      // First mark the session as not new
+      sessionManager.startSession()
+      expect(sessionManager.getState().isNewSession).to.be.false
+
+      // Update the preset prompt
+      sessionManager.updatePreset('new-preset')
+
+      // Verify the session is marked as new
+      expect(sessionManager.getState().isNewSession).to.be.true
+    })
+
+    it('should clear the system prompt', () => {
+      // Simulate having an existing system prompt
+      sessionManager.getSystemPrompt('en')
+      expect(sessionManager.getState().systemPrompt).to.not.equal('')
+
+      // Update the preset prompt
+      sessionManager.updatePreset('new-preset')
+
+      // Verify the system prompt is cleared
+      expect(sessionManager.getState().systemPrompt).to.equal('')
+    })
+  })
+
+  describe('getSystemPrompt', () => {
+    it('should load system prompt if session is new', () => {
+      // Using sinon would encounter import issues, so we simply test behavior here
+      const result = sessionManager.getSystemPrompt('en')
+
+      // Verify it returned a non-empty string
+      expect(result).to.be.a('string')
+      expect(result).to.not.equal('')
+
+      // Verify the state was updated
+      expect(sessionManager.getState().systemPrompt).to.equal(result)
+    })
+
+    it('should return cached system prompt if session is not new', () => {
+      // Get the system prompt for the first time
+      const firstPrompt = sessionManager.getSystemPrompt('en')
+
+      // Mark the session as not new
+      sessionManager.startSession()
+
+      // Get the system prompt again
+      const secondPrompt = sessionManager.getSystemPrompt('en')
+
+      // Verify the same prompt is returned
+      expect(secondPrompt).to.equal(firstPrompt)
+    })
+
+    it('should reload system prompt if empty even if session is not new', () => {
+      // Get the system prompt for the first time
+      sessionManager.getSystemPrompt('en')
+
+      // Mark the session as not new
+      sessionManager.startSession()
+
+      // Manually clear the system prompt
+      sessionManager['state'].systemPrompt = ''
+
+      // Get the system prompt again
+      const reloadedPrompt = sessionManager.getSystemPrompt('en')
+
+      // Verify it returned a non-empty prompt
+      expect(reloadedPrompt).to.be.a('string')
+      expect(reloadedPrompt).to.not.equal('')
+    })
+  })
+})
diff --git a/tests/unit/utils/ai/copilot.spec.ts b/tests/unit/utils/ai/copilot.spec.ts
@@ -0,0 +1,116 @@
+import { expect } from 'chai'
+import { loadSystemPrompt, getModelProvider, AImodelsOptions } from '@/utils/ai/copilot'
+
+describe('copilot', () => {
+  describe('loadSystemPrompt', () => {
+    it('should load base prompt with language', () => {
+      const result = loadSystemPrompt('en')
+
+      // Check if it includes the base prompt
+      expect(result).to.include('You are MQTTX Copilot')
+
+      // Check if it includes language setting
+      expect(result).to.include('Please answer in English')
+    })
+
+    it('should include different content based on language', () => {
+      const zhResult = loadSystemPrompt('zh')
+      const enResult = loadSystemPrompt('en')
+      const jaResult = loadSystemPrompt('ja')
+
+      expect(zhResult).to.include('请使用中文回答')
+      expect(enResult).to.include('Please answer in English')
+      expect(jaResult).to.include('日本語で回答してください')
+    })
+
+    it('should handle undefined command parameter', () => {
+      const result = loadSystemPrompt('en', undefined)
+
+      // Result should include base prompt but not command-specific prompts
+      expect(result).to.include('You are MQTTX Copilot')
+      expect(result).to.include('Please answer in English')
+    })
+
+    it('should handle different command inputs', () => {
+      // Here we only test that the function handles different commands without throwing errors
+      expect(() => loadSystemPrompt('en', 'some-code-command')).to.not.throw()
+      expect(() => loadSystemPrompt('en', 'some-payload-command')).to.not.throw()
+      expect(() => loadSystemPrompt('en', 'some-emqx-command')).to.not.throw()
+      expect(() => loadSystemPrompt('en', 'some-mqtt-faq-command')).to.not.throw()
+      expect(() => loadSystemPrompt('en', 'some-function-command')).to.not.throw()
+      expect(() => loadSystemPrompt('en', 'some-schema-command')).to.not.throw()
+    })
+  })
+
+  describe('AImodelsOptions', () => {
+    it('should contain all supported providers', () => {
+      const providerNames = AImodelsOptions.map((provider) => provider.value)
+
+      expect(providerNames).to.include('OpenAI')
+      expect(providerNames).to.include('DeepSeek')
+      expect(providerNames).to.include('Anthropic')
+      expect(providerNames).to.include('xAI')
+      expect(providerNames).to.include('SiliconFlow')
+    })
+
+    it('should have valid model options for each provider', () => {
+      // Check OpenAI provider
+      const openAI = AImodelsOptions.find((p) => p.value === 'OpenAI')
+      expect(openAI).to.exist
+      expect(openAI?.children).to.be.an('array').that.is.not.empty
+      expect(openAI?.children.map((c) => c.value)).to.include('gpt-4o')
+
+      // Check DeepSeek provider
+      const deepSeek = AImodelsOptions.find((p) => p.value === 'DeepSeek')
+      expect(deepSeek).to.exist
+      expect(deepSeek?.children).to.be.an('array').that.is.not.empty
+      expect(deepSeek?.children.map((c) => c.value)).to.include('deepseek-chat')
+
+      // Check Anthropic provider
+      const anthropic = AImodelsOptions.find((p) => p.value === 'Anthropic')
+      expect(anthropic).to.exist
+      expect(anthropic?.children).to.be.an('array').that.is.not.empty
+      expect(anthropic?.children.map((c) => c.value)).to.include('claude-3-opus-latest')
+    })
+
+    it('should have provider creator functions', () => {
+      // Verify each provider has a creator function
+      AImodelsOptions.forEach((provider) => {
+        expect(provider.providerCreator).to.be.a('function')
+      })
+    })
+  })
+
+  describe('getModelProvider', () => {
+    it('should accept valid parameters', () => {
+      // This test only verifies the function accepts parameters without throwing errors
+      expect(() => {
+        getModelProvider({
+          model: 'gpt-4o',
+          baseURL: 'https://api.openai.com/v1',
+          apiKey: 'test-key',
+        })
+      }).to.not.throw()
+    })
+
+    it('should work with different model types', () => {
+      // Verify the function can handle different model types
+      const validModels = [
+        'gpt-4o', // OpenAI
+        'deepseek-chat', // DeepSeek
+        'claude-3-opus-latest', // Anthropic
+        'grok-2-1212', // xAI
+      ]
+
+      validModels.forEach((model) => {
+        expect(() => {
+          getModelProvider({
+            model: model as any,
+            baseURL: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+          })
+        }).to.not.throw()
+      })
+    })
+  })
+})
