lobe-chat

1
import { describe } from 'vitest';
2

3
import { MigrationData, VersionController } from '@/migrations/VersionController';
4

5
import { MigrationV1ToV2 } from '../FromV1ToV2';
6
import inputV1Data from '../FromV1ToV2/fixtures/input-v1-session.json';
7
import { MigrationV2ToV3 } from '../FromV2ToV3';
8
import azureInputV3 from './fixtures/azure-input-v3.json';
9
import azureOutputV4 from './fixtures/azure-output-v4.json';
10
import ollamaInputV3 from './fixtures/ollama-input-v3.json';
11
import ollamaOutputV4 from './fixtures/ollama-output-v4.json';
12
import openaiInputV3 from './fixtures/openai-input-v3.json';
13
import openaiOutputV4 from './fixtures/openai-output-v4.json';
14
import openrouterInputV3 from './fixtures/openrouter-input-v3.json';
15
import openrouterOutputV4 from './fixtures/openrouter-output-v4.json';
16
import outputV4Data from './fixtures/output-v4-from-v1.json';
17
import { MigrationV3ToV4 } from './index';
18

19
describe('MigrationV3ToV4', () => {
20
  let migrations;
21
  let versionController: VersionController<any>;
22

23
  beforeEach(() => {
24
    migrations = [MigrationV3ToV4];
25
    versionController = new VersionController(migrations, 4);
26
  });
27

28
  describe('should migrate data correctly from previous versions', () => {
29
    it('openai', () => {
30
      const data: MigrationData = openaiInputV3;
31

32
      const migratedData = versionController.migrate(data);
33

34
      expect(migratedData.version).toEqual(openaiOutputV4.version);
35
      expect(migratedData.state.settings.languageModel).toEqual(
36
        openaiOutputV4.state.settings.languageModel,
37
      );
38
    });
39

40
    it('azure', () => {
41
      const data: MigrationData = azureInputV3;
42

43
      const migratedData = versionController.migrate(data);
44

45
      expect(migratedData.version).toEqual(azureOutputV4.version);
46
      expect(migratedData.state.settings.languageModel).toEqual(
47
        azureOutputV4.state.settings.languageModel,
48
      );
49
    });
50

51
    it('openrouter', () => {
52
      const data: MigrationData = openrouterInputV3;
53

54
      const migratedData = versionController.migrate(data);
55

56
      expect(migratedData.version).toEqual(openrouterOutputV4.version);
57
      expect(migratedData.state.settings.languageModel).toEqual(
58
        openrouterOutputV4.state.settings.languageModel,
59
      );
60
    });
61

62
    it('ollama', () => {
63
      const data: MigrationData = ollamaInputV3;
64

65
      const migratedData = versionController.migrate(data);
66

67
      expect(migratedData.version).toEqual(ollamaOutputV4.version);
68
      expect(migratedData.state.settings.languageModel).toEqual(
69
        ollamaOutputV4.state.settings.languageModel,
70
      );
71
    });
72
  });
73

74
  it('should work correct from v1 to v4', () => {
75
    const data: MigrationData = inputV1Data;
76

77
    versionController = new VersionController(
78
      [MigrationV3ToV4, MigrationV2ToV3, MigrationV1ToV2],
79
      4,
80
    );
81

82
    const migratedData = versionController.migrate(data);
83

84
    expect(migratedData.version).toEqual(outputV4Data.version);
85
    // expect(migratedData.state.sessions).toEqual(outputV3DataFromV1.state.sessions);
86
    // expect(migratedData.state.topics).toEqual(outputV3DataFromV1.state.topics);
87
    // expect(migratedData.state.messages).toEqual(outputV3DataFromV1.state.messages);
88
  });
89

90
  describe('Edge Case', () => {
91
    it('should handle undefined settings or languageModel', () => {
92
      const data: MigrationData = {
93
        version: 3,
94
        state: {
95
          // settings undefined
96
        },
97
      };
98

99
      const migratedData = versionController.migrate(data);
100

101
      expect(migratedData.version).toEqual(4);
102
      expect(migratedData.state.settings).toBeUndefined();
103
    });
104

105
    it('should handle undefined languageModel', () => {
106
      const data: MigrationData = {
107
        version: 3,
108
        state: {
109
          settings: {
110
            // languageModel undefined
111
          },
112
        },
113
      };
114

115
      const migratedData = versionController.migrate(data);
116

117
      expect(migratedData.version).toEqual(4);
118
      expect(migratedData.state.settings.languageModel).toBeUndefined();
119
    });
120

121
    it('should handle missing provider configurations', () => {
122
      const data: MigrationData = {
123
        version: 3,
124
        state: {
125
          settings: {
126
            languageModel: {
127
              // missing togetherai、openrouter 、 ollama
128
              openAI: {
129
                // openAI
130
              },
131
            },
132
          },
133
        },
134
      };
135

136
      const migratedData = versionController.migrate(data);
137

138
      expect(migratedData.version).toEqual(4);
139
      expect(migratedData.state.settings.languageModel.togetherai).toBeUndefined();
140
      expect(migratedData.state.settings.languageModel.openrouter).toBeUndefined();
141
      expect(migratedData.state.settings.languageModel.ollama).toBeUndefined();
142
    });
143

144
    it('should success for invalid data format', () => {
145
      const data: MigrationData = {
146
        version: 3,
147
        state: {
148
          settings: {
149
            languageModel: {
150
              openAI: 'invalid-config', // 错误的配置格式
151
            },
152
          },
153
        },
154
      };
155

156
      const migratedData = versionController.migrate(data);
157

158
      expect(migratedData.version).toEqual(4);
159
      expect(migratedData.state.settings.languageModel.openai).toEqual({ enabled: true });
160
      expect(migratedData.state.settings.languageModel.togetherai).toBeUndefined();
161
      expect(migratedData.state.settings.languageModel.openrouter).toBeUndefined();
162
      expect(migratedData.state.settings.languageModel.ollama).toBeUndefined();
163
    });
164

165
    it('should handle empty strings and empty objects', () => {
166
      const data: MigrationData = {
167
        version: 3,
168
        state: {
169
          settings: {
170
            languageModel: {
171
              openAI: undefined,
172
              togetherai: {
173
                apiKey: '',
174
                endpoint: '',
175
                customModelName: '',
176
              },
177
            },
178
          },
179
        },
180
      };
181

182
      const migratedData = versionController.migrate(data);
183

184
      expect(migratedData.version).toEqual(4);
185
      expect(migratedData.state.settings.languageModel.openai).toEqual({
186
        apiKey: '',
187
        enabled: true,
188
      });
189

190
      expect(migratedData.state.settings.languageModel.togetherai.apiKey).toEqual('');
191
      expect(migratedData.state.settings.languageModel.togetherai.endpoint).toEqual('');
192
      expect(migratedData.state.settings.languageModel.togetherai.customModelCards).toBeUndefined();
193
    });
194
  });
195
});
196