mirror of
https://github.com/eigent-ai/eigent.git
synced 2026-05-24 05:26:42 +00:00
af93bb3065
Co-authored-by: a7m-1st <Ahmed.jimi.awelkeir500@gmail.com> Co-authored-by: eigent-ai <camel@eigent.ai> Co-authored-by: Wendong-Fan <133094783+Wendong-Fan@users.noreply.github.com> Co-authored-by: Wendong-Fan <w3ndong.fan@gmail.com>
415 lines
15 KiB
TypeScript
415 lines
15 KiB
TypeScript
// ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
|
|
|
|
/**
|
|
* Focused tests for the complex installation state detection logic in createWindow
|
|
* This tests the decision matrix for when installation is needed vs when it's not
|
|
*/
|
|
|
|
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
|
|
import { setupMockEnvironment } from '../../../mocks/environmentMocks';
|
|
|
|
describe('createWindow - Installation State Detection Logic', () => {
|
|
let mockEnv: ReturnType<typeof setupMockEnvironment>;
|
|
let installationStateChecker: (mockState: any) => Promise<boolean>;
|
|
|
|
beforeEach(() => {
|
|
mockEnv = setupMockEnvironment();
|
|
|
|
// Extract the installation decision logic for focused testing
|
|
installationStateChecker = async (mockState) => {
|
|
const currentVersion = mockState.app.currentVersion;
|
|
const versionExists = mockState.filesystem.versionFileExists;
|
|
const savedVersion = versionExists
|
|
? mockState.filesystem.versionFileContent
|
|
: '';
|
|
const uvExists = mockState.filesystem.binariesExist['uv'] || false;
|
|
const bunExists = mockState.filesystem.binariesExist['bun'] || false;
|
|
const installationCompleted = mockState.filesystem.installedLockExists;
|
|
|
|
return (
|
|
!versionExists ||
|
|
savedVersion !== currentVersion ||
|
|
!uvExists ||
|
|
!bunExists ||
|
|
!installationCompleted
|
|
);
|
|
};
|
|
});
|
|
|
|
afterEach(() => {
|
|
mockEnv.reset();
|
|
});
|
|
|
|
describe('Version File Scenarios', () => {
|
|
it('should require installation when version file does not exist', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = false;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should require installation when saved version differs from current version', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '0.9.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should not require installation when versions match', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(false);
|
|
});
|
|
|
|
it('should handle version file with whitespace correctly', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = ' 1.0.0 \n';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
// In the real code, version content is trimmed
|
|
const trimmedVersion =
|
|
mockEnv.mockState.filesystem.versionFileContent.trim();
|
|
const needsInstallation =
|
|
trimmedVersion !== mockEnv.mockState.app.currentVersion ||
|
|
!mockEnv.mockState.filesystem.binariesExist['uv'] ||
|
|
!mockEnv.mockState.filesystem.binariesExist['bun'] ||
|
|
!mockEnv.mockState.filesystem.installedLockExists;
|
|
|
|
expect(needsInstallation).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('Binary Existence Scenarios', () => {
|
|
it('should require installation when uv binary is missing', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: false, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should require installation when bun binary is missing', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: false };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should require installation when both binaries are missing', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: false, bun: false };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Installation Lock File Scenarios', () => {
|
|
it('should require installation when lock file is missing', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = false;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should not require installation when lock file exists', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('Combined Failure Scenarios', () => {
|
|
it('should require installation when multiple conditions fail', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = false;
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: false, bun: false };
|
|
mockEnv.mockState.filesystem.installedLockExists = false;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should require installation when version mismatch AND missing binaries', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '0.9.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: false, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should require installation when only lock file is present', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = false;
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: false, bun: false };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Edge Cases and Boundaries', () => {
|
|
it('should handle empty version strings', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
|
|
it('should handle version with special characters', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0-beta.1';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0-beta.1';
|
|
mockEnv.mockState.filesystem.binariesExist = { uv: true, bun: true };
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(false);
|
|
});
|
|
|
|
it('should handle null or undefined binary states', async () => {
|
|
mockEnv.mockState.filesystem.versionFileExists = true;
|
|
mockEnv.mockState.filesystem.versionFileContent = '1.0.0';
|
|
mockEnv.mockState.app.currentVersion = '1.0.0';
|
|
mockEnv.mockState.filesystem.binariesExist = {};
|
|
mockEnv.mockState.filesystem.installedLockExists = true;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Platform-Specific Binary Detection', () => {
|
|
it('should check for .exe extension on Windows', async () => {
|
|
mockEnv.scenarios.missingEigentDirectories();
|
|
mockEnv.mockState.system.platform = 'win32';
|
|
|
|
// Test that binary detection considers .exe files on Windows
|
|
expect(mockEnv.processUtilsMock.getBinaryName('uv')).resolves.toBe(
|
|
'uv.exe'
|
|
);
|
|
});
|
|
|
|
it('should not add .exe extension on macOS', async () => {
|
|
mockEnv.scenarios.macOSEnvironment();
|
|
|
|
expect(mockEnv.processUtilsMock.getBinaryName('uv')).resolves.toBe('uv');
|
|
});
|
|
|
|
it('should not add .exe extension on Linux', async () => {
|
|
mockEnv.scenarios.linuxEnvironment();
|
|
|
|
expect(mockEnv.processUtilsMock.getBinaryName('uv')).resolves.toBe('uv');
|
|
});
|
|
});
|
|
|
|
describe('Decision Matrix Verification', () => {
|
|
// This test verifies the complete decision matrix
|
|
const testCases = [
|
|
{
|
|
name: 'All conditions met - no installation needed',
|
|
setup: {
|
|
versionFileExists: true,
|
|
versionFileContent: '1.0.0',
|
|
currentVersion: '1.0.0',
|
|
uvExists: true,
|
|
bunExists: true,
|
|
installedLockExists: true,
|
|
},
|
|
expectedNeedsInstallation: false,
|
|
},
|
|
{
|
|
name: 'Missing version file',
|
|
setup: {
|
|
versionFileExists: false,
|
|
versionFileContent: '',
|
|
currentVersion: '1.0.0',
|
|
uvExists: true,
|
|
bunExists: true,
|
|
installedLockExists: true,
|
|
},
|
|
expectedNeedsInstallation: true,
|
|
},
|
|
{
|
|
name: 'Version mismatch',
|
|
setup: {
|
|
versionFileExists: true,
|
|
versionFileContent: '0.9.0',
|
|
currentVersion: '1.0.0',
|
|
uvExists: true,
|
|
bunExists: true,
|
|
installedLockExists: true,
|
|
},
|
|
expectedNeedsInstallation: true,
|
|
},
|
|
{
|
|
name: 'Missing uv binary',
|
|
setup: {
|
|
versionFileExists: true,
|
|
versionFileContent: '1.0.0',
|
|
currentVersion: '1.0.0',
|
|
uvExists: false,
|
|
bunExists: true,
|
|
installedLockExists: true,
|
|
},
|
|
expectedNeedsInstallation: true,
|
|
},
|
|
{
|
|
name: 'Missing bun binary',
|
|
setup: {
|
|
versionFileExists: true,
|
|
versionFileContent: '1.0.0',
|
|
currentVersion: '1.0.0',
|
|
uvExists: true,
|
|
bunExists: false,
|
|
installedLockExists: true,
|
|
},
|
|
expectedNeedsInstallation: true,
|
|
},
|
|
{
|
|
name: 'Missing installation lock',
|
|
setup: {
|
|
versionFileExists: true,
|
|
versionFileContent: '1.0.0',
|
|
currentVersion: '1.0.0',
|
|
uvExists: true,
|
|
bunExists: true,
|
|
installedLockExists: false,
|
|
},
|
|
expectedNeedsInstallation: true,
|
|
},
|
|
];
|
|
|
|
testCases.forEach(({ name, setup, expectedNeedsInstallation }) => {
|
|
it(`should correctly handle: ${name}`, async () => {
|
|
// Set up the mock state according to the test case
|
|
mockEnv.mockState.filesystem.versionFileExists =
|
|
setup.versionFileExists;
|
|
mockEnv.mockState.filesystem.versionFileContent =
|
|
setup.versionFileContent;
|
|
mockEnv.mockState.app.currentVersion = setup.currentVersion;
|
|
mockEnv.mockState.filesystem.binariesExist = {
|
|
uv: setup.uvExists,
|
|
bun: setup.bunExists,
|
|
};
|
|
mockEnv.mockState.filesystem.installedLockExists =
|
|
setup.installedLockExists;
|
|
|
|
const needsInstallation = await installationStateChecker(
|
|
mockEnv.mockState
|
|
);
|
|
expect(needsInstallation).toBe(expectedNeedsInstallation);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Logging Verification', () => {
|
|
it('should log installation check results', async () => {
|
|
// This test ensures that the installation decision logic provides proper logging
|
|
const mockState = mockEnv.mockState;
|
|
|
|
const logData = {
|
|
needsInstallation: await installationStateChecker(mockState),
|
|
versionExists: mockState.filesystem.versionFileExists,
|
|
versionMatch:
|
|
mockState.filesystem.versionFileContent ===
|
|
mockState.app.currentVersion,
|
|
uvExists: mockState.filesystem.binariesExist['uv'] || false,
|
|
bunExists: mockState.filesystem.binariesExist['bun'] || false,
|
|
installationCompleted: mockState.filesystem.installedLockExists,
|
|
};
|
|
|
|
// Verify that all required data for logging is available
|
|
expect(logData).toHaveProperty('needsInstallation');
|
|
expect(logData).toHaveProperty('versionExists');
|
|
expect(logData).toHaveProperty('versionMatch');
|
|
expect(logData).toHaveProperty('uvExists');
|
|
expect(logData).toHaveProperty('bunExists');
|
|
expect(logData).toHaveProperty('installationCompleted');
|
|
|
|
// Verify the logic is consistent
|
|
const expectedNeedsInstallation =
|
|
!logData.versionExists ||
|
|
!logData.versionMatch ||
|
|
!logData.uvExists ||
|
|
!logData.bunExists ||
|
|
!logData.installationCompleted;
|
|
|
|
expect(logData.needsInstallation).toBe(expectedNeedsInstallation);
|
|
});
|
|
});
|
|
});
|