From 07084bc9e547c74e97c24689083dea557e7b533f Mon Sep 17 00:00:00 2001 From: YuShifan <894402575bt@gmail.com> Date: Tue, 3 Sep 2024 16:55:19 +0800 Subject: [PATCH] test(desktop): add more utils test cases --- src/utils/mqttErrorReason.ts | 5 +- src/utils/mqttUtils.ts | 8 +- tests/unit/components/ResizeHeight.spec.ts | 77 +++++++++++++ tests/unit/utils/SystemTopicUtils.spec.ts | 72 ++++++++++++ tests/unit/utils/convertPayload.spec.ts | 95 ++++++++++++++++ tests/unit/utils/copilot.spec.ts | 46 ++++++++ tests/unit/utils/delay.spec.ts | 29 +++++ tests/unit/utils/exportData.spec.ts | 70 ++++++++++++ tests/unit/utils/gaCustomLinks.spec.ts | 59 ++++++++++ .../unit/utils/getContextmenuPosition.spec.ts | 84 ++++++++++++++ tests/unit/utils/getFiles.spec.ts | 57 ++++++++++ tests/unit/utils/handleString.spec.ts | 67 ++++++++++++ tests/unit/utils/idGenerator.spec.ts | 103 ++++++++++++++++++ tests/unit/utils/jsonUtils.spec.ts | 75 +++++++++++++ tests/unit/utils/matchMultipleSearch.spec.ts | 88 +++++++++++++++ tests/unit/utils/mqttErrorReason.spec.ts | 65 +++++++++++ tests/unit/utils/protobuf.spec.ts | 79 ++++++++++++++ tests/unit/utils/protobufErrors.spec.ts | 41 +++++++ tests/unit/utils/time.spec.ts | 2 +- 19 files changed, 1116 insertions(+), 6 deletions(-) create mode 100644 tests/unit/components/ResizeHeight.spec.ts create mode 100644 tests/unit/utils/SystemTopicUtils.spec.ts create mode 100644 tests/unit/utils/convertPayload.spec.ts create mode 100644 tests/unit/utils/copilot.spec.ts create mode 100644 tests/unit/utils/delay.spec.ts create mode 100644 tests/unit/utils/exportData.spec.ts create mode 100644 tests/unit/utils/gaCustomLinks.spec.ts create mode 100644 tests/unit/utils/getContextmenuPosition.spec.ts create mode 100644 tests/unit/utils/getFiles.spec.ts create mode 100644 tests/unit/utils/handleString.spec.ts create mode 100644 tests/unit/utils/idGenerator.spec.ts create mode 100644 tests/unit/utils/jsonUtils.spec.ts create mode 100644 tests/unit/utils/matchMultipleSearch.spec.ts create mode 100644 tests/unit/utils/mqttErrorReason.spec.ts create mode 100644 tests/unit/utils/protobuf.spec.ts create mode 100644 tests/unit/utils/protobufErrors.spec.ts diff --git a/src/utils/mqttErrorReason.ts b/src/utils/mqttErrorReason.ts index fb6c5e32c..42f252f23 100644 --- a/src/utils/mqttErrorReason.ts +++ b/src/utils/mqttErrorReason.ts @@ -51,8 +51,11 @@ const MqttErrorReason: Record = { type MqttVersion = '3.1' | '3.1.1' | '5.0' -const getErrorReason = (version: MqttVersion, code: number) => { +const getErrorReason = (version: MqttVersion, code: number): string => { const versionMap = MqttErrorReason[version] + if (!versionMap) { + return 'Unknown error' + } return versionMap[code] ?? 'Unknown error' } diff --git a/src/utils/mqttUtils.ts b/src/utils/mqttUtils.ts index 75ab8dc79..3a47a0ebb 100644 --- a/src/utils/mqttUtils.ts +++ b/src/utils/mqttUtils.ts @@ -5,7 +5,7 @@ import time from '@/utils/time' import { getSSLFile } from '@/utils/getFiles' import _ from 'lodash' -const setMQTT5Properties = ({ clean, properties: option }: ConnectionModel) => { +export const setMQTT5Properties = ({ clean, properties: option }: ConnectionModel) => { if (option === undefined) { return undefined } @@ -21,7 +21,7 @@ const setMQTT5Properties = ({ clean, properties: option }: ConnectionModel) => { return Object.fromEntries(Object.entries(properties).filter(([_, v]) => v !== null && v !== undefined)) } -const setWillMQTT5Properties = (option: WillPropertiesModel) => { +export const setWillMQTT5Properties = (option: WillPropertiesModel) => { if (option === undefined) { return undefined } @@ -29,7 +29,7 @@ const setWillMQTT5Properties = (option: WillPropertiesModel) => { return Object.fromEntries(Object.entries(properties).filter(([_, v]) => v !== null && v !== undefined)) } -const getClientOptions = (record: ConnectionModel): IClientOptions => { +export const getClientOptions = (record: ConnectionModel): IClientOptions => { const mqttVersionDict = { '3.1': 3, '3.1.1': 4, @@ -127,7 +127,7 @@ const getClientOptions = (record: ConnectionModel): IClientOptions => { return options } -const getUrl = (record: ConnectionModel): string => { +export const getUrl = (record: ConnectionModel): string => { const { host, port, path } = record const protocol = getMQTTProtocol(record) diff --git a/tests/unit/components/ResizeHeight.spec.ts b/tests/unit/components/ResizeHeight.spec.ts new file mode 100644 index 000000000..c94b99f95 --- /dev/null +++ b/tests/unit/components/ResizeHeight.spec.ts @@ -0,0 +1,77 @@ +import { expect } from 'chai' +import { shallowMount, Wrapper } from '@vue/test-utils' +import ResizeHeight from '@/components/ResizeHeight.vue' +import { Vue } from 'vue-property-decorator' + +describe('ResizeHeight.vue', () => { + let wrapper: Wrapper + + beforeEach(() => { + wrapper = shallowMount(ResizeHeight, { + propsData: { + value: 100, + }, + }) + }) + + afterEach(() => { + wrapper.destroy() + }) + + it('renders correctly', () => { + expect(wrapper.find('.resize-height').exists()).to.be.true + }) + + it('emits change event on mousedown and mousemove', async () => { + const vm = wrapper.vm as any + + // Call handleMousedown directly + vm.handleMousedown({ y: 100 } as MouseEvent) + + // Simulate mousemove + const mousemoveEvent = { y: 150 } as MouseEvent + document.onmousemove!(mousemoveEvent) + + await Vue.nextTick() + + expect(wrapper.emitted('change')).to.exist + const emittedValue = wrapper.emitted('change')![0][0] + expect(typeof emittedValue).to.equal('number') + expect(emittedValue).to.equal(50) + }) + + it('adds select-none class to body on mousemove', async () => { + const vm = wrapper.vm as any + vm.handleMousedown({ y: 100 } as MouseEvent) + + const mousemoveEvent = { y: 150 } as MouseEvent + document.onmousemove!(mousemoveEvent) + + await Vue.nextTick() + + expect(document.body.classList.contains('select-none')).to.be.true + }) + + it('removes select-none class from body on mouseup', async () => { + document.body.classList.add('select-none') + + const mouseupEvent = new MouseEvent('mouseup') + document.dispatchEvent(mouseupEvent) + + await Vue.nextTick() + + expect(document.body.classList.contains('select-none')).to.be.false + }) + + it('removes mousemove event listener on mouseup', async () => { + const vm = wrapper.vm as any + vm.handleMousedown({ y: 100 } as MouseEvent) + + const mouseupEvent = new MouseEvent('mouseup') + document.dispatchEvent(mouseupEvent) + + await Vue.nextTick() + + expect(document.onmousemove).to.be.null + }) +}) diff --git a/tests/unit/utils/SystemTopicUtils.spec.ts b/tests/unit/utils/SystemTopicUtils.spec.ts new file mode 100644 index 000000000..00db8ea9c --- /dev/null +++ b/tests/unit/utils/SystemTopicUtils.spec.ts @@ -0,0 +1,72 @@ +import { expect } from 'chai' +import * as SystemTopicUtils from '@/utils/SystemTopicUtils' +import time from '@/utils/time' + +describe('SystemTopicUtils', () => { + let originalGetNowDate: () => string + + beforeEach(() => { + originalGetNowDate = time.getNowDate + time.getNowDate = () => '2023-01-01 00:00:00' + }) + + afterEach(() => { + time.getNowDate = originalGetNowDate + }) + + describe('getBytes', () => { + it('should return chart data for received bytes', () => { + const message = { topic: '/metrics/bytes/received', payload: '100' } + const result = SystemTopicUtils.getBytes(message as MessageModel) + expect(result).to.deep.equal({ + label: '2023-01-01 00:00:00', + recevied: 100, + sent: 0, + }) + }) + + it('should return chart data for sent bytes', () => { + const message = { topic: '/metrics/bytes/sent', payload: '200' } + const result = SystemTopicUtils.getBytes(message as MessageModel) + expect(result).to.deep.equal({ + label: '2023-01-01 00:00:00', + recevied: 100, + sent: 200, + }) + }) + + it('should return null for unrelated topics', () => { + const message = { topic: '/other/topic', payload: '300' } + const result = SystemTopicUtils.getBytes(message as MessageModel) + expect(result).to.be.null + }) + }) + + describe('getUptime', () => { + it('should return uptime data', () => { + const message = { topic: '/uptime', payload: '1000' } + const result = SystemTopicUtils.getUptime(message as MessageModel) + expect(result).to.equal('1000') + }) + + it('should return null for unrelated topics', () => { + const message = { topic: '/other/topic', payload: '1000' } + const result = SystemTopicUtils.getUptime(message as MessageModel) + expect(result).to.be.null + }) + }) + + describe('getVersion', () => { + it('should return version data', () => { + const message = { topic: '/version', payload: '1.0.0' } + const result = SystemTopicUtils.getVersion(message as MessageModel) + expect(result).to.equal('1.0.0') + }) + + it('should return null for unrelated topics', () => { + const message = { topic: '/other/topic', payload: '1.0.0' } + const result = SystemTopicUtils.getVersion(message as MessageModel) + expect(result).to.be.null + }) + }) +}) diff --git a/tests/unit/utils/convertPayload.spec.ts b/tests/unit/utils/convertPayload.spec.ts new file mode 100644 index 000000000..5508f4d3b --- /dev/null +++ b/tests/unit/utils/convertPayload.spec.ts @@ -0,0 +1,95 @@ +import { expect } from 'chai' +import convertPayload from '@/utils/convertPayload' + +describe('convertPayload', () => { + it('should convert Base64 to plain text', async () => { + const base64Payload = 'SGVsbG8gV29ybGQ=' + const result = await convertPayload(base64Payload, 'Plaintext', 'Base64') + expect(result).to.equal('Hello World') + }) + + it('should convert plain text to Base64', async () => { + const plainPayload = 'Hello World' + const result = await convertPayload(plainPayload, 'Base64', 'Plaintext') + expect(result).to.equal('SGVsbG8gV29ybGQ=') + }) + + it('should convert Hex to plain text', async () => { + const hexPayload = '48 65 6c 6c 6f 20 57 6f 72 6c 64' + const result = await convertPayload(hexPayload, 'Plaintext', 'Hex') + expect(result).to.equal('Hello World') + }) + + it('should convert plain text to Hex', async () => { + const plainPayload = 'Hello World' + const result = await convertPayload(plainPayload, 'Hex', 'Plaintext') + expect(result).to.equal('4865 6c6c 6f20 576f 726c 64') + }) + + it('should convert JSON to plain text', async () => { + const jsonPayload = '{"key": "value"}' + const result = await convertPayload(jsonPayload, 'Plaintext', 'JSON') + expect(result).to.equal('{"key": "value"}') + }) + + it('should convert Hex to Base64', async () => { + const hexPayload = '48 65 6c 6c 6f 20 57 6f 72 6c 64' + const result = await convertPayload(hexPayload, 'Base64', 'Hex') + expect(result).to.equal('SGVsbG8gV29ybGQ=') + }) + + it('should convert Base64 to Hex', async () => { + const base64Payload = 'SGVsbG8gV29ybGQ=' + const result = await convertPayload(base64Payload, 'Hex', 'Base64') + expect(result).to.equal('4865 6c6c 6f20 576f 726c 64') + }) + + it('should handle empty input', async () => { + const emptyPayload = '' + const result = await convertPayload(emptyPayload, 'Base64', 'Plaintext') + expect(result).to.equal('') + }) + + it('should handle whitespace-only input', async () => { + const whitespacePayload = ' ' + const result = await convertPayload(whitespacePayload, 'Base64', 'Plaintext') + expect(result).to.equal('ICAg') + }) + + it('should handle special characters', async () => { + const specialCharsPayload = '!@#$%^&*()_+' + const result = await convertPayload(specialCharsPayload, 'Base64', 'Plaintext') + expect(result).to.equal('IUAjJCVeJiooKV8r') + }) + + it('should handle Unicode characters', async () => { + const unicodePayload = '你好，世界' + const result = await convertPayload(unicodePayload, 'Base64', 'Plaintext') + expect(result).to.equal('5L2g5aW977yM5LiW55WM') + }) + + it('should handle large integers', async () => { + const largeIntPayload = '9007199254740991' + const result = await convertPayload(largeIntPayload, 'Base64', 'Plaintext') + expect(result).to.equal('OTAwNzE5OTI1NDc0MDk5MQ==') + }) + + // JSON conversion tests are commented out due to issues casued by jsonUtils jsonStringify + /* + it('should convert plain text to JSON', async () => { + const plainPayload = '{"key": "value"}' + const result = await convertPayload(plainPayload, 'JSON', 'Plaintext') + expect(result).to.equal('{\n "key": "value"\n}') + }) + + it('should handle invalid JSON conversion', async () => { + const invalidPayload = 'Not a JSON' + try { + await convertPayload(invalidPayload, 'JSON', 'Plaintext') + expect.fail('Should have thrown an error') + } catch (error) { + expect(error).to.be.an('error') + } + }) + */ +}) diff --git a/tests/unit/utils/copilot.spec.ts b/tests/unit/utils/copilot.spec.ts new file mode 100644 index 000000000..c2de06818 --- /dev/null +++ b/tests/unit/utils/copilot.spec.ts @@ -0,0 +1,46 @@ +import { expect } from 'chai' +import { processStream } from '@/utils/copilot' + +describe('Copilot', () => { + describe('processStream', () => { + it('should process stream data and invoke callback for each content', async () => { + let readCount = 0 + const mockReader = { + read: async () => { + readCount++ + if (readCount === 1) { + return { + done: false, + value: new TextEncoder().encode('data: {"choices":[{"delta":{"content":"Hello"}}]}\n\n'), + } + } else if (readCount === 2) { + return { + done: false, + value: new TextEncoder().encode('data: {"choices":[{"delta":{"content":" World"}}]}\n\n'), + } + } else { + return { done: true } + } + }, + } + + const mockResponse = { + body: { + getReader: () => mockReader, + }, + } as unknown as Response + + const callbackResults: string[] = [] + const callback = (content: string) => { + callbackResults.push(content) + } + + const result = await processStream(mockResponse, callback) + + expect(result).to.be.true + expect(callbackResults).to.have.lengthOf(2) + expect(callbackResults[0]).to.equal('Hello') + expect(callbackResults[1]).to.equal(' World') + }) + }) +}) diff --git a/tests/unit/utils/delay.spec.ts b/tests/unit/utils/delay.spec.ts new file mode 100644 index 000000000..c92d22cba --- /dev/null +++ b/tests/unit/utils/delay.spec.ts @@ -0,0 +1,29 @@ +import { expect } from 'chai' +import delay from '@/utils/delay' + +describe('delay', () => { + it('should delay execution for the specified time', async () => { + const startTime = Date.now() + const delayTime = 100 // 100 milliseconds + + await delay(delayTime) + + const endTime = Date.now() + const elapsedTime = endTime - startTime + + // Allow for some small variance in timing + expect(elapsedTime).to.be.at.least(delayTime) + expect(elapsedTime).to.be.below(delayTime + 50) + }) + + it('should resolve without error', async () => { + try { + await delay(50) + // If we reach this point, the promise resolved successfully + expect(true).to.be.true + } catch (error) { + // If we catch an error, the test should fail + expect.fail('delay function threw an error') + } + }) +}) diff --git a/tests/unit/utils/exportData.spec.ts b/tests/unit/utils/exportData.spec.ts new file mode 100644 index 000000000..efcb21688 --- /dev/null +++ b/tests/unit/utils/exportData.spec.ts @@ -0,0 +1,70 @@ +import { expect } from 'chai' +import { + typeNull, + typeUndefined, + emptyString, + emptyArray, + emptyObject, + specialDataTypes, + stringProps, + replaceSpecialDataTypes, + recoverSpecialDataTypes, + recoverSpecialDataTypesFromString, +} from '@/utils/exportData' + +describe('exportData utility functions', () => { + describe('Constants', () => { + it('should have correct values for special data types', () => { + expect(typeNull).to.equal('TYPE_NULL') + expect(typeUndefined).to.equal('TYPE_UNDEFINED') + expect(emptyString).to.equal('EMPTY_STRING') + expect(emptyArray).to.equal('EMPTY_ARRAY') + expect(emptyObject).to.equal('EMPTY_OBJECT') + }) + + it('should have correct specialDataTypes array', () => { + expect(specialDataTypes).to.deep.equal([typeNull, typeUndefined, emptyString, emptyArray, emptyObject]) + }) + + it('should have correct stringProps array', () => { + expect(stringProps).to.include.members([ + 'clientId', + 'name', + 'mqttVersion', + 'password', + 'topic', + 'username', + 'lastWillPayload', + 'lastWillTopic', + 'contentType', + ]) + }) + }) + + describe('replaceSpecialDataTypes', () => { + it('should replace special data types in JSON string', () => { + const input = '{"a": null, "b": undefined, "c": "", "d": [], "e": {}}' + const expected = `{"a": "${typeNull}", "b": "${typeUndefined}", "c": "${emptyString}", "d": "${emptyArray}", "e": "${emptyObject}"}` + expect(replaceSpecialDataTypes(input)).to.equal(expected) + }) + }) + + describe('recoverSpecialDataTypes', () => { + it('should recover special data types from string', () => { + expect(recoverSpecialDataTypes(typeNull)).to.be.null + expect(recoverSpecialDataTypes(typeUndefined)).to.be.undefined + expect(recoverSpecialDataTypes(emptyString)).to.equal('') + expect(recoverSpecialDataTypes(emptyArray)).to.deep.equal([]) + expect(recoverSpecialDataTypes(emptyObject)).to.deep.equal({}) + expect(recoverSpecialDataTypes('normal')).to.equal('normal') + }) + }) + + describe('recoverSpecialDataTypesFromString', () => { + it('should recover special data types in JSON string', () => { + const input = `{"a": "${typeNull}", "b": "${typeUndefined}", "c": "${emptyString}", "d": "${emptyArray}", "e": "${emptyObject}"}` + const expected = '{"a": null, "b": undefined, "c": "", "d": [], "e": {}}' + expect(recoverSpecialDataTypesFromString(input)).to.equal(expected) + }) + }) +}) diff --git a/tests/unit/utils/gaCustomLinks.spec.ts b/tests/unit/utils/gaCustomLinks.spec.ts new file mode 100644 index 000000000..10801c5c2 --- /dev/null +++ b/tests/unit/utils/gaCustomLinks.spec.ts @@ -0,0 +1,59 @@ +import { expect } from 'chai' +import gaCustomLinks from '@/utils/gaCustomLinks' +import version from '@/version' + +describe('gaCustomLinks utility function', () => { + it('should return correct links for English language', () => { + const links = gaCustomLinks('en') + + expect(links.MQTTXSite).to.equal('https://mqttx.app') + expect(links.EMQSite).to.equal('https://emqx.com/en') + expect(links.forumSite).to.equal('https://github.com/emqx/MQTTX/discussions') + + const utm = '?utm_source=mqttx&utm_medium=referral&utm_campaign=' + expect(links.leftBarLogo).to.equal(`https://mqttx.app${utm}logo-to-homepage`) + + expect(links.empty.EMQX).to.equal(`https://emqx.com/en/products/emqx${utm}mqttx-to-emqx`) + expect(links.empty.EMQXCloud).to.equal(`https://emqx.com/en/cloud${utm}mqttx-to-cloud`) + + expect(links.about.releases).to.equal(`https://mqttx.app/changelogs/v${version}${utm}about-to-release`) + expect(links.about.faq).to.equal(`https://mqttx.app/docs/faq${utm}about-to-faq`) + expect(links.about.MQTTX).to.equal(`https://mqttx.app${utm}about-to-mqttx`) + expect(links.about.EMQ).to.equal(`https://emqx.com/en${utm}mqttx-to-homepage`) + expect(links.about.EMQXCloud).to.equal(`https://emqx.com/en/cloud${utm}mqttx-to-cloud`) + + expect(links.help.docs).to.equal(`https://mqttx.app/docs${utm}mqttx-help-to-docs`) + expect(links.help.forum).to.equal(`https://github.com/emqx/MQTTX/discussions${utm}mqttx-help-to-forum`) + expect(links.help.learnMQTT).to.equal(`https://emqx.com/en/mqtt-guide${utm}mqttx-help-to-learn-mqtt`) + expect(links.help.publicMqttBroker).to.equal(`https://emqx.com/en/mqtt/public-mqtt5-broker`) + expect(links.help.mqtt5).to.equal(`https://emqx.com/en/mqtt/mqtt5`) + expect(links.help.blogUtm).to.equal(`${utm}mqttx-help-to-blog`) + }) + + it('should return correct links for Chinese language', () => { + const links = gaCustomLinks('zh') + + expect(links.MQTTXSite).to.equal('https://mqttx.app/zh') + expect(links.EMQSite).to.equal('https://emqx.com/zh') + expect(links.forumSite).to.equal('https://askemq.com/c/tools/11') + + const utm = '?utm_source=mqttx&utm_medium=referral&utm_campaign=' + expect(links.leftBarLogo).to.equal(`https://mqttx.app/zh${utm}logo-to-homepage`) + + expect(links.empty.EMQX).to.equal(`https://emqx.com/zh/products/emqx${utm}mqttx-to-emqx`) + expect(links.empty.EMQXCloud).to.equal(`https://emqx.com/zh/cloud${utm}mqttx-to-cloud`) + + expect(links.about.releases).to.equal(`https://mqttx.app/zh/changelogs/v${version}${utm}about-to-release`) + expect(links.about.faq).to.equal(`https://mqttx.app/zh/docs/faq${utm}about-to-faq`) + expect(links.about.MQTTX).to.equal(`https://mqttx.app/zh${utm}about-to-mqttx`) + expect(links.about.EMQ).to.equal(`https://emqx.com/zh${utm}mqttx-to-homepage`) + expect(links.about.EMQXCloud).to.equal(`https://emqx.com/zh/cloud${utm}mqttx-to-cloud`) + + expect(links.help.docs).to.equal(`https://mqttx.app/zh/docs${utm}mqttx-help-to-docs`) + expect(links.help.forum).to.equal(`https://askemq.com/c/tools/11${utm}mqttx-help-to-forum`) + expect(links.help.learnMQTT).to.equal(`https://emqx.com/zh/mqtt-guide${utm}mqttx-help-to-learn-mqtt`) + expect(links.help.publicMqttBroker).to.equal(`https://emqx.com/zh/mqtt/public-mqtt5-broker`) + expect(links.help.mqtt5).to.equal(`https://emqx.com/zh/mqtt/mqtt5`) + expect(links.help.blogUtm).to.equal(`${utm}mqttx-help-to-blog`) + }) +}) diff --git a/tests/unit/utils/getContextmenuPosition.spec.ts b/tests/unit/utils/getContextmenuPosition.spec.ts new file mode 100644 index 000000000..3236bce45 --- /dev/null +++ b/tests/unit/utils/getContextmenuPosition.spec.ts @@ -0,0 +1,84 @@ +import { expect } from 'chai' +import getContextmenuPosition from '@/utils/getContextmenuPosition' + +describe('getContextmenuPosition', () => { + let originalInnerWidth: number + let originalInnerHeight: number + + beforeEach(() => { + originalInnerWidth = window.innerWidth + originalInnerHeight = window.innerHeight + // Set a fixed window size for testing + Object.defineProperty(window, 'innerWidth', { value: 1024, writable: true }) + Object.defineProperty(window, 'innerHeight', { value: 768, writable: true }) + }) + + afterEach(() => { + // Restore original window size + Object.defineProperty(window, 'innerWidth', { value: originalInnerWidth, writable: true }) + Object.defineProperty(window, 'innerHeight', { value: originalInnerHeight, writable: true }) + }) + + it('should return correct position when menu fits within window', () => { + const event = { clientX: 100, clientY: 100 } as MouseEvent + const width = 200 + const height = 150 + + const result = getContextmenuPosition(event, width, height) + + expect(result.x).to.equal(100) + expect(result.y).to.equal(100) + }) + + it('should adjust x position when menu would overflow right edge', () => { + const event = { clientX: 900, clientY: 100 } as MouseEvent + const width = 200 + const height = 150 + + const result = getContextmenuPosition(event, width, height) + + expect(result.x).to.equal(824) // 1024 - 200 + expect(result.y).to.equal(100) + }) + + it('should adjust y position when menu would overflow bottom edge', () => { + const event = { clientX: 100, clientY: 700 } as MouseEvent + const width = 200 + const height = 150 + + const result = getContextmenuPosition(event, width, height) + + expect(result.x).to.equal(100) + expect(result.y).to.equal(618) // 768 - 150 + }) + + it('should adjust both x and y positions when menu would overflow both edges', () => { + const event = { clientX: 900, clientY: 700 } as MouseEvent + const width = 200 + const height = 150 + + const result = getContextmenuPosition(event, width, height) + + expect(result.x).to.equal(824) // 1024 - 200 + expect(result.y).to.equal(618) // 768 - 150 + }) + + it('should use document.documentElement.clientWidth/Height if innerWidth/Height are not available', () => { + // Mock innerWidth/Height to be undefined + Object.defineProperty(window, 'innerWidth', { value: undefined, writable: true }) + Object.defineProperty(window, 'innerHeight', { value: undefined, writable: true }) + + // Mock document.documentElement.clientWidth/Height + Object.defineProperty(document.documentElement, 'clientWidth', { value: 1024, writable: true }) + Object.defineProperty(document.documentElement, 'clientHeight', { value: 768, writable: true }) + + const event = { clientX: 900, clientY: 700 } as MouseEvent + const width = 200 + const height = 150 + + const result = getContextmenuPosition(event, width, height) + + expect(result.x).to.equal(824) // 1024 - 200 + expect(result.y).to.equal(618) // 768 - 150 + }) +}) diff --git a/tests/unit/utils/getFiles.spec.ts b/tests/unit/utils/getFiles.spec.ts new file mode 100644 index 000000000..e5408f0ed --- /dev/null +++ b/tests/unit/utils/getFiles.spec.ts @@ -0,0 +1,57 @@ +import { expect } from 'chai' +import { getSSLFile } from '@/utils/getFiles' +import fs from 'fs' + +describe('getSSLFile', () => { + it('should return SSL content when valid paths are provided', () => { + const sslPath = { + ca: 'test-ca.pem', + cert: 'test-cert.pem', + key: 'test-key.pem', + } + + const originalReadFileSync = fs.readFileSync + fs.readFileSync = ((path: string) => { + if (path === 'test-ca.pem') return Buffer.from('ca-content') + if (path === 'test-cert.pem') return Buffer.from('cert-content') + if (path === 'test-key.pem') return Buffer.from('key-content') + throw new Error('Unexpected file path') + }) as typeof fs.readFileSync + + const result = getSSLFile(sslPath) + + expect(result).to.deep.equal({ + ca: [Buffer.from('ca-content')], + cert: Buffer.from('cert-content'), + key: Buffer.from('key-content'), + }) + + fs.readFileSync = originalReadFileSync + }) + + it('should return undefined for empty paths', () => { + const sslPath = { + ca: '', + cert: '', + key: '', + } + + const result = getSSLFile(sslPath) + + expect(result).to.deep.equal({ + ca: undefined, + cert: undefined, + key: undefined, + }) + }) + + it('should throw an error when file reading fails', () => { + const sslPath = { + ca: 'non-existent.pem', + cert: '', + key: '', + } + + expect(() => getSSLFile(sslPath)).to.throw() + }) +}) diff --git a/tests/unit/utils/handleString.spec.ts b/tests/unit/utils/handleString.spec.ts new file mode 100644 index 000000000..a5f602d5d --- /dev/null +++ b/tests/unit/utils/handleString.spec.ts @@ -0,0 +1,67 @@ +import { expect } from 'chai' +import { emptyToNull } from '@/utils/handleString' + +describe('handleString', () => { + describe('emptyToNull', () => { + it('should convert empty strings to null', () => { + const input = { name: '', age: 30, email: '' } + const result = emptyToNull(input) + expect(result).to.deep.equal({ name: null, age: 30, email: null }) + }) + + it('should not modify non-empty strings', () => { + const input = { name: 'John', age: 30, email: 'john@example.com' } + const result = emptyToNull(input) + expect(result).to.deep.equal(input) + }) + + it('should handle objects with nested properties', () => { + const input = { user: { name: '', age: 30 }, settings: { theme: '' } } + const result = emptyToNull(input) + expect(result).to.deep.equal({ user: { name: '', age: 30 }, settings: { theme: '' } }) + }) + + it('should handle arrays', () => { + const input = { names: ['', 'John', ''] } + const result = emptyToNull(input) + expect(result).to.deep.equal({ names: ['', 'John', ''] }) + }) + + it('should not modify null or undefined values', () => { + const input = { name: null, age: undefined, email: '' } + const result = emptyToNull(input) + expect(result).to.deep.equal({ name: null, age: undefined, email: null }) + }) + + it('should handle empty object', () => { + const input = {} + const result = emptyToNull(input) + expect(result).to.deep.equal({}) + }) + + it('should handle object with only empty strings', () => { + const input = { a: '', b: '', c: '' } + const result = emptyToNull(input) + expect(result).to.deep.equal({ a: null, b: null, c: null }) + }) + + it('should not modify non-string properties', () => { + const input = { name: '', age: 0, isActive: false, score: NaN } + const result = emptyToNull(input) + expect(result).to.deep.equal({ name: null, age: 0, isActive: false, score: NaN }) + }) + + it('should handle object with Symbol keys', () => { + const symbolKey = Symbol('test') + const input = { [symbolKey]: '' } + const result = emptyToNull(input) + expect(result[symbolKey]).to.equal('') + }) + + it('should return the same object reference', () => { + const input = { name: '' } + const result = emptyToNull(input) + expect(result).to.equal(input) + }) + }) +}) diff --git a/tests/unit/utils/idGenerator.spec.ts b/tests/unit/utils/idGenerator.spec.ts new file mode 100644 index 000000000..6e62c543e --- /dev/null +++ b/tests/unit/utils/idGenerator.spec.ts @@ -0,0 +1,103 @@ +import { expect } from 'chai' +import { + getClientId, + getCollectionId, + getSubscriptionId, + getMessageId, + getCopilotMessageId, + ENCRYPT_KEY, +} from '@/utils/idGenerator' + +describe('idGenerator', () => { + describe('getClientId', () => { + it('should return a string starting with "mqttx_"', () => { + const clientId = getClientId() + expect(clientId).to.be.a('string') + expect(clientId).to.match(/^mqttx_[a-f0-9]{8}$/) + }) + + it('should generate unique IDs', () => { + const ids = new Set() + for (let i = 0; i < 1000; i++) { + ids.add(getClientId()) + } + expect(ids.size).to.equal(1000) + }) + }) + + describe('getCollectionId', () => { + it('should return a string starting with "collection_"', () => { + const collectionId = getCollectionId() + expect(collectionId).to.be.a('string') + expect(collectionId).to.match(/^collection_[a-f0-9-]{36}$/) + }) + + it('should generate unique IDs', () => { + const ids = new Set() + for (let i = 0; i < 1000; i++) { + ids.add(getCollectionId()) + } + expect(ids.size).to.equal(1000) + }) + }) + + describe('getSubscriptionId', () => { + it('should return a string starting with "scription_"', () => { + const subscriptionId = getSubscriptionId() + expect(subscriptionId).to.be.a('string') + expect(subscriptionId).to.match(/^scription_[a-f0-9-]{36}$/) + }) + + it('should generate unique IDs', () => { + const ids = new Set() + for (let i = 0; i < 1000; i++) { + ids.add(getSubscriptionId()) + } + expect(ids.size).to.equal(1000) + }) + }) + + describe('getMessageId', () => { + it('should return a string starting with "message_"', () => { + const messageId = getMessageId() + expect(messageId).to.be.a('string') + expect(messageId).to.match(/^message_[a-f0-9-]{36}$/) + }) + + it('should generate unique IDs', () => { + const ids = new Set() + for (let i = 0; i < 1000; i++) { + ids.add(getMessageId()) + } + expect(ids.size).to.equal(1000) + }) + }) + + describe('getCopilotMessageId', () => { + it('should return a string starting with "copilot_"', () => { + const copilotMessageId = getCopilotMessageId() + expect(copilotMessageId).to.be.a('string') + expect(copilotMessageId).to.match(/^copilot_[a-f0-9-]{36}$/) + }) + + it('should generate unique IDs', () => { + const ids = new Set() + for (let i = 0; i < 1000; i++) { + ids.add(getCopilotMessageId()) + } + expect(ids.size).to.equal(1000) + }) + }) + + describe('ENCRYPT_KEY', () => { + it('should be a base64 encoded string', () => { + expect(ENCRYPT_KEY).to.be.a('string') + expect(Buffer.from(ENCRYPT_KEY, 'base64').toString('base64')).to.equal(ENCRYPT_KEY) + }) + + it('should have the correct value', () => { + const expectedValue = Buffer.from('123e4567-e89b-12d3-a456-426614174000').toString('base64') + expect(ENCRYPT_KEY).to.equal(expectedValue) + }) + }) +}) diff --git a/tests/unit/utils/jsonUtils.spec.ts b/tests/unit/utils/jsonUtils.spec.ts new file mode 100644 index 000000000..10268deaf --- /dev/null +++ b/tests/unit/utils/jsonUtils.spec.ts @@ -0,0 +1,75 @@ +import { expect } from 'chai' +import { jsonParse, jsonStringify } from '@/utils/jsonUtils' + +describe('jsonUtils', () => { + describe('jsonParse', () => { + it('should parse JSON with large integers correctly', () => { + const json = '{"bigInt": 9007199254740991}' + const result = jsonParse(json) + expect(result.bigInt.toString()).to.equal('9007199254740991') + }) + + it('should parse JSON with floating-point numbers correctly', () => { + const json = '{"float": 123.456}' + const result = jsonParse(json) + expect(result.float).to.equal(123.456) + }) + + it('should throw an error for invalid JSON', () => { + const invalidJson = '{invalid: json}' + expect(() => jsonParse(invalidJson)).to.throw() + }) + + it('should parse mixed JSON correctly', () => { + const json = '{"bigInt": 9007199254740991, "float": 123.456, "string": "test"}' + const result = jsonParse(json) + expect(result.bigInt.toString()).to.equal('9007199254740991') + expect(result.float).to.equal(123.456) + expect(result.string).to.equal('test') + }) + + it('should parse normal JSON correctly', () => { + const json = '{"name": "John Doe", "age": 30, "isStudent": false}' + const result = jsonParse(json) + expect(result).to.deep.equal({ + name: 'John Doe', + age: 30, + isStudent: false, + }) + }) + }) + + // TODO: FIX IT with TypeError: Right-hand side of 'instanceof' is not callable + describe('jsonStringify', () => { + // it('should stringify normal JSON correctly', () => { + // const obj = { name: 'John Doe', age: 30, isStudent: false } + // const result = jsonStringify(obj) + // expect(result).to.equal('{"name":"John Doe","age":30,"isStudent":false}') + // }) + // it('should stringify objects with large integers correctly', () => { + // const obj = { bigInt: BigInt(Number.MAX_SAFE_INTEGER) } + // const result = jsonStringify(obj) + // expect(result).to.equal('{"bigInt":9007199254740991}') + // }) + // it('should stringify objects with floating-point numbers correctly', () => { + // const obj = { float: 123.456 } + // const result = jsonStringify(obj) + // expect(result).to.equal('{"float":123.456}') + // }) + // it('should stringify mixed objects correctly', () => { + // const obj = { bigInt: BigInt(Number.MAX_SAFE_INTEGER), float: 123.456, string: 'test' } + // const result = jsonStringify(obj) + // expect(result).to.equal('{"bigInt":9007199254740991,"float":123.456,"string":"test"}') + // }) + // it('should handle BigInt correctly', () => { + // const bigIntValue = BigInt(Number.MAX_SAFE_INTEGER) + // const stringified = jsonStringify(bigIntValue) + // expect(stringified).to.equal('9007199254740991') + // }) + // it('should handle arrays with mixed types', () => { + // const arr = [BigInt(Number.MAX_SAFE_INTEGER), 123.456, 'test', true] + // const result = jsonStringify(arr) + // expect(result).to.equal('[9007199254740991,123.456,"test",true]') + // }) + }) +}) diff --git a/tests/unit/utils/matchMultipleSearch.spec.ts b/tests/unit/utils/matchMultipleSearch.spec.ts new file mode 100644 index 000000000..8a949d593 --- /dev/null +++ b/tests/unit/utils/matchMultipleSearch.spec.ts @@ -0,0 +1,88 @@ +import { expect } from 'chai' +import matchMultipleSearch from '@/utils/matchMultipleSearch' + +describe('matchMultipleSearch', () => { + const testData = [ + { name: 'John Doe', age: '30', city: 'New York' }, + { name: 'Jane Smith', age: '25', city: 'Los Angeles' }, + { name: 'Bob Johnson', age: '35', city: 'Chicago' }, + { name: 'Alice Brown', age: '28', city: 'San Francisco' }, + ] + + it('should match partial name search', async () => { + const result = await matchMultipleSearch(testData, { name: 'john' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(2) + expect(result!.map((item) => item.name)).to.include.members(['John Doe', 'Bob Johnson']) + }) + + it('should match multiple parameter search', async () => { + const result = await matchMultipleSearch(testData, { name: 'j', age: '30' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(1) + expect(result![0].name).to.equal('John Doe') + }) + + it('should be case insensitive', async () => { + const result = await matchMultipleSearch(testData, { name: 'JOHN' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(2) + expect(result!.map((item) => item.name)).to.include.members(['John Doe', 'Bob Johnson']) + }) + + it('should ignore whitespace', async () => { + const result = await matchMultipleSearch(testData, { name: ' john doe ' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(1) + expect(result![0].name).to.equal('John Doe') + }) + + it('should handle special characters', async () => { + const specialData = [{ name: 'John@Doe' }, { name: 'Jane@Smith' }] + const result = await matchMultipleSearch(specialData, { name: 'john@' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(1) + expect(result![0].name).to.equal('John@Doe') + }) + + it('should return empty array for no matches', async () => { + const result = await matchMultipleSearch(testData, { name: 'xyz' }) + expect(result).to.not.be.null + expect(result!).to.be.an('array').that.is.empty + }) + + it('should handle missing properties', async () => { + const result = await matchMultipleSearch(testData, { nonexistent: 'value' }) + expect(result).to.not.be.null + expect(result!).to.be.an('array').that.is.empty + }) + + it('should match partial strings', async () => { + const result = await matchMultipleSearch(testData, { city: 'new' }) + expect(result).to.not.be.null + expect(result!).to.have.lengthOf(1) + expect(result![0].name).to.equal('John Doe') + }) + + it('should handle empty search params', async () => { + const result = await matchMultipleSearch(testData, {}) + expect(result).to.not.be.null + expect(result!).to.deep.equal(testData) + }) + + it('should handle empty data array', async () => { + const result = await matchMultipleSearch([], { name: 'John' }) + expect(result).to.not.be.null + expect(result!).to.be.an('array').that.is.empty + }) + + it('should reject on error', async () => { + const invalidData: any = null + try { + await matchMultipleSearch(invalidData, { name: 'John' }) + expect.fail('Should have thrown an error') + } catch (error) { + expect(error).to.be.an('error') + } + }) +}) diff --git a/tests/unit/utils/mqttErrorReason.spec.ts b/tests/unit/utils/mqttErrorReason.spec.ts new file mode 100644 index 000000000..c9de95557 --- /dev/null +++ b/tests/unit/utils/mqttErrorReason.spec.ts @@ -0,0 +1,65 @@ +import { expect } from 'chai' +import getErrorReason from '@/utils/mqttErrorReason' + +describe('mqttErrorReason', () => { + describe('getErrorReason', () => { + it('should return correct error reason for MQTT 3.1', () => { + expect(getErrorReason('3.1', 128)).to.equal('Not authorized') + }) + + it('should return correct error reason for MQTT 3.1.1', () => { + expect(getErrorReason('3.1.1', 128)).to.equal('Not authorized') + }) + + describe('MQTT 5.0', () => { + it('should return correct error reasons for various codes', () => { + expect(getErrorReason('5.0', 4)).to.equal('Disconnect with Will Message') + expect(getErrorReason('5.0', 16)).to.equal('No matching subscribers') + expect(getErrorReason('5.0', 128)).to.equal('Unspecified error') + expect(getErrorReason('5.0', 135)).to.equal('Not authorized') + expect(getErrorReason('5.0', 149)).to.equal('Packet too large') + expect(getErrorReason('5.0', 162)).to.equal('Wildcard Subscriptions not supported') + }) + + it('should return "Unknown error" for undefined error codes', () => { + expect(getErrorReason('5.0', 999)).to.equal('Unknown error') + }) + }) + + it('should return "Unknown error" for undefined versions', () => { + // @ts-ignore: Intentionally passing an invalid version + expect(getErrorReason('6.0', 128)).to.equal('Unknown error') + }) + + it('should handle edge cases', () => { + expect(getErrorReason('5.0', 0)).to.equal('Unknown error') + expect(getErrorReason('5.0', -1)).to.equal('Unknown error') + // @ts-ignore: Intentionally passing an invalid version + expect(getErrorReason(undefined, 128)).to.equal('Unknown error') + // @ts-ignore: Intentionally passing an invalid version + expect(getErrorReason(null, 128)).to.equal('Unknown error') + }) + }) + + describe('Error code coverage', () => { + it('should have all MQTT 5.0 error codes defined', () => { + const definedCodes = [ + 4, 16, 17, 24, 25, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + ] + + definedCodes.forEach((code) => { + expect(getErrorReason('5.0', code)).to.not.equal('Unknown error', `Error code ${code} should be defined`) + }) + }) + }) + + describe('Version compatibility', () => { + it('should have consistent "Not authorized" message across versions', () => { + const notAuthorizedMessage = 'Not authorized' + expect(getErrorReason('3.1', 128)).to.equal(notAuthorizedMessage) + expect(getErrorReason('3.1.1', 128)).to.equal(notAuthorizedMessage) + expect(getErrorReason('5.0', 135)).to.equal(notAuthorizedMessage) + }) + }) +}) diff --git a/tests/unit/utils/protobuf.spec.ts b/tests/unit/utils/protobuf.spec.ts new file mode 100644 index 000000000..3dcaeddfc --- /dev/null +++ b/tests/unit/utils/protobuf.spec.ts @@ -0,0 +1,79 @@ +import { expect } from 'chai' +import { + checkProtobufInput, + serializeProtobufToBuffer, + deserializeBufferToProtobuf, + printObjectAsString, +} from '@/utils/protobuf' + +describe('Protobuf Utils', () => { + const sampleProto = ` + syntax = "proto3"; + message Person { + string name = 1; + int32 age = 2; + } + ` + + describe('checkProtobufInput', () => { + it('should validate correct protobuf input', () => { + const input = JSON.stringify({ name: 'Alice', age: 30 }) + const result = checkProtobufInput(sampleProto, input, 'Person') + expect(result).to.be.a('string') + expect(result).to.include('Alice') + expect(result).to.include('30') + }) + + it('should throw error for invalid protobuf input', () => { + const input = JSON.stringify({ name: 'Bob', age: 'invalid' }) + expect(() => checkProtobufInput(sampleProto, input, 'Person')).to.throw('Message Test Failed') + }) + }) + + describe('serializeProtobufToBuffer', () => { + it('should serialize valid input to buffer', () => { + const input = JSON.stringify({ name: 'Charlie', age: 25 }) + const result = serializeProtobufToBuffer(input, sampleProto, 'Person') + expect(result).to.be.instanceof(Buffer) + }) + + it('should throw error for invalid input', () => { + const input = JSON.stringify({ name: 'David', age: 'invalid' }) + expect(() => serializeProtobufToBuffer(input, sampleProto, 'Person')).to.throw('Message serialization error') + }) + }) + + describe('deserializeBufferToProtobuf', () => { + it('should deserialize buffer to protobuf object', () => { + const input = JSON.stringify({ name: 'Eve', age: 28 }) + const buffer = serializeProtobufToBuffer(input, sampleProto, 'Person') + if (buffer) { + const result = deserializeBufferToProtobuf(buffer, sampleProto, 'Person') + expect(result).to.be.a('string') + expect(result).to.include('Eve') + expect(result).to.include('28') + } else { + expect.fail('Buffer should not be undefined') + } + }) + + it('should throw error for invalid buffer', () => { + const invalidBuffer = Buffer.from('invalid data') + expect(() => deserializeBufferToProtobuf(invalidBuffer, sampleProto, 'Person')).to.throw( + 'Message deserialization error', + ) + }) + }) + + describe('printObjectAsString', () => { + it('should print object as formatted string', () => { + const obj = { name: 'Frank', age: 35, address: { city: 'New York', zip: '10001' } } + const result = printObjectAsString(obj) + expect(result).to.be.a('string') + expect(result).to.include('name: "Frank"') + expect(result).to.include('age: 35') + expect(result).to.include('city: "New York"') + expect(result).to.include('zip: "10001"') + }) + }) +}) diff --git a/tests/unit/utils/protobufErrors.spec.ts b/tests/unit/utils/protobufErrors.spec.ts new file mode 100644 index 000000000..7980855c8 --- /dev/null +++ b/tests/unit/utils/protobufErrors.spec.ts @@ -0,0 +1,41 @@ +import { expect } from 'chai' +import { transformPBJSError } from '@/utils/protobufErrors' + +describe('protobufErrors', () => { + describe('transformPBJSError', () => { + it('should prepend "Message deserialization error: " to the error message', () => { + const error = new Error('Test error') + const transformedError = transformPBJSError(error) + expect(transformedError.message).to.equal('Message deserialization error: Test error') + }) + + it('should transform index out of range error message', () => { + const error = new Error('index out of range: 10 + 5 > 12') + const transformedError = transformPBJSError(error) + expect(transformedError.message).to.equal( + 'Message deserialization error: Index out of range: the reader was at position 10 and tried to read 5 more (bytes), but the given buffer was 12 bytes', + ) + }) + + it('should not transform non-index out of range error messages', () => { + const error = new Error('Some other error') + const transformedError = transformPBJSError(error) + expect(transformedError.message).to.equal('Message deserialization error: Some other error') + }) + + it('should handle errors with complex index out of range messages', () => { + const error = new Error('Multiple errors occurred: 1) index out of range: 15 + 8 > 20 2) Another error') + const transformedError = transformPBJSError(error) + expect(transformedError.message).to.equal( + 'Message deserialization error: Multiple errors occurred: 1) Index out of range: the reader was at position 15 and tried to read 8 more (bytes), but the given buffer was 20 bytes 2) Another error', + ) + }) + + it('should return a new Error instance', () => { + const error = new Error('Test error') + const transformedError = transformPBJSError(error) + expect(transformedError).to.be.instanceOf(Error) + expect(transformedError).to.not.equal(error) + }) + }) +}) diff --git a/tests/unit/utils/time.spec.ts b/tests/unit/utils/time.spec.ts index 0d1bc5fe2..dea141bc2 100644 --- a/tests/unit/utils/time.spec.ts +++ b/tests/unit/utils/time.spec.ts @@ -2,7 +2,7 @@ import { expect } from 'chai' import moment from 'moment' import { getNowDate, toFormat, convertSecondsToMs, sqliteDateFormat } from '@/utils/time' -describe('time utility functions', () => { +describe('time utility', () => { it('getNowDate should return current date in the specified format', () => { const now = getNowDate() expect(now).to.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}:\d{3}$/)