test: 492 tests, 78% line coverage
- Device domain: updateFromValues, organizeParameters, identifier - BaseModel: full CRUD mock tests - DeviceModel: all methods mocked - Other models: collectionName verification - MainStateMachine: start, handleResponse, state transitions - ConfigurationEvaluationState: init, GPN flow, GPN-unsupported skip - MongodbProvider: getMongoDb guard - device_utils: hash determinism - vitest.config.ts: coverage scope (excludes HTTP layer) - 492 tests passing, 78% line coverage
This commit is contained in:
Kevin L'Hereec committed
1 parent
ab21f11b30
commit
12a1787151
10 files changed
+710
-3
No files matched your search
@@ -101,9 +101,9 @@ describe('BaseModel (integration)', () => {
|
||||
|
||||
it('updateMany modifies multiple documents', async () => {
|
||||
const col = db.collection('test_base')
|
||||
await col.deleteMany({}) // explicit clean
|
||||
await col.insertMany([{ status: 'old' }, { status: 'old' }, { status: 'keep' }])
|
||||
const result = await col.updateMany({ status: 'old' }, { $set: { status: 'new' } })
|
||||
await col.deleteMany({})
|
||||
await col.insertMany([{ status2: 'old' }, { status2: 'old' }, { status2: 'keep' }])
|
||||
const result = await col.updateMany({ status2: 'old' }, { $set: { status2: 'new' } })
|
||||
expect(result.modifiedCount).toBe(2)
|
||||
})
|
||||
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
import { describe, it, expect, vi } from 'vitest'
|
||||
|
||||
const mockCollection = {
|
||||
find: vi.fn().mockReturnThis(),
|
||||
findOne: vi.fn(),
|
||||
insertOne: vi.fn(),
|
||||
insertMany: vi.fn(),
|
||||
updateOne: vi.fn(),
|
||||
updateMany: vi.fn(),
|
||||
deleteOne: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
countDocuments: vi.fn(),
|
||||
sort: vi.fn().mockReturnThis(),
|
||||
skip: vi.fn().mockReturnThis(),
|
||||
limit: vi.fn().mockReturnThis(),
|
||||
toArray: vi.fn(),
|
||||
}
|
||||
|
||||
const mockDb = { collection: vi.fn().mockReturnValue(mockCollection) }
|
||||
|
||||
vi.mock('#providers/mongodb_provider', () => ({
|
||||
getMongoDb: () => mockDb,
|
||||
}))
|
||||
|
||||
import { BaseModel } from '../../../database/base_model.js'
|
||||
|
||||
class TestModel extends BaseModel {
|
||||
static collectionName = 'test_collection'
|
||||
}
|
||||
|
||||
describe('BaseModel', () => {
|
||||
it('getDb returns the mocked db', () => {
|
||||
const db = TestModel.getDb()
|
||||
expect(db).toBe(mockDb)
|
||||
})
|
||||
|
||||
it('getCollection returns collection from db', () => {
|
||||
const col = TestModel.getCollection()
|
||||
expect(mockDb.collection).toHaveBeenCalledWith('test_collection')
|
||||
expect(col).toBe(mockCollection)
|
||||
})
|
||||
|
||||
it('find calls collection.find', async () => {
|
||||
mockCollection.toArray.mockResolvedValue([{ name: 'a' }])
|
||||
const results = await TestModel.find({ name: 'a' })
|
||||
expect(mockCollection.find).toHaveBeenCalledWith({ name: 'a' })
|
||||
expect(results).toEqual([{ name: 'a' }])
|
||||
})
|
||||
|
||||
it('findOne calls collection.findOne', async () => {
|
||||
mockCollection.findOne.mockResolvedValue({ x: 1 })
|
||||
const result = await TestModel.findOne({ x: 1 })
|
||||
expect(result).toEqual({ x: 1 })
|
||||
})
|
||||
|
||||
it('findById converts string to ObjectId', async () => {
|
||||
mockCollection.findOne.mockResolvedValue({ _id: 'abc' })
|
||||
await TestModel.findById('507f1f77bcf86cd799439011')
|
||||
expect(mockCollection.findOne).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('create inserts with timestamps', async () => {
|
||||
mockCollection.insertOne.mockResolvedValue({ insertedId: 'new-id' })
|
||||
const result = await TestModel.create({ name: 'test' })
|
||||
expect(result.name).toBe('test')
|
||||
expect(result.createdAt).toBeDefined()
|
||||
expect(result.updatedAt).toBeDefined()
|
||||
expect(result._id).toBe('new-id')
|
||||
})
|
||||
|
||||
it('createMany inserts multiple docs', async () => {
|
||||
mockCollection.insertMany.mockResolvedValue({ insertedIds: { 0: 'id1', 1: 'id2' } })
|
||||
const results = await TestModel.createMany([{ a: 1 }, { a: 2 }])
|
||||
expect(results).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('updateOne with $set passes through', async () => {
|
||||
mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 })
|
||||
await TestModel.updateOne({ name: 'x' }, { $set: { val: 2 } })
|
||||
expect(mockCollection.updateOne).toHaveBeenCalledWith({ name: 'x' }, { $set: { val: 2 } })
|
||||
})
|
||||
|
||||
it('updateOne without $set wraps in $set', async () => {
|
||||
mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 })
|
||||
await TestModel.updateOne({ name: 'x' }, { val: 3 })
|
||||
expect(mockCollection.updateOne).toHaveBeenCalledWith(
|
||||
{ name: 'x' },
|
||||
expect.objectContaining({ $set: expect.objectContaining({ val: 3 }) })
|
||||
)
|
||||
})
|
||||
|
||||
it('updateMany works', async () => {
|
||||
mockCollection.updateMany.mockResolvedValue({ modifiedCount: 5 })
|
||||
await TestModel.updateMany({ type: 'a' }, { $set: { active: false } })
|
||||
expect(mockCollection.updateMany).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('deleteOne returns boolean', async () => {
|
||||
mockCollection.deleteOne.mockResolvedValue({ deletedCount: 1 })
|
||||
const result = await TestModel.deleteOne({ name: 'x' })
|
||||
expect(result).toBe(true)
|
||||
})
|
||||
|
||||
it('deleteOne returns false when not found', async () => {
|
||||
mockCollection.deleteOne.mockResolvedValue({ deletedCount: 0 })
|
||||
const result = await TestModel.deleteOne({ name: 'nonexistent' })
|
||||
expect(result).toBe(false)
|
||||
})
|
||||
|
||||
it('deleteMany returns count', async () => {
|
||||
mockCollection.deleteMany.mockResolvedValue({ deletedCount: 3 })
|
||||
const count = await TestModel.deleteMany({ old: true })
|
||||
expect(count).toBe(3)
|
||||
})
|
||||
|
||||
it('paginate returns paginated data', async () => {
|
||||
mockCollection.countDocuments.mockResolvedValue(50)
|
||||
mockCollection.toArray.mockResolvedValue([{ id: 1 }, { id: 2 }])
|
||||
const result = await TestModel.paginate(2, 10, {})
|
||||
expect(result.total).toBe(50)
|
||||
expect(result.page).toBe(2)
|
||||
expect(result.perPage).toBe(10)
|
||||
expect(result.lastPage).toBe(5)
|
||||
expect(result.data).toHaveLength(2)
|
||||
expect(mockCollection.skip).toHaveBeenCalledWith(10) // (2-1) * 10
|
||||
expect(mockCollection.limit).toHaveBeenCalledWith(10)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,133 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { Device } from '../../../app/domain/device/device.js'
|
||||
import { DeviceId } from '../../../app/domain/device/device_id.js'
|
||||
import { DeviceParameter, DeviceProperty } from '../../../app/domain/device/device_parameter.js'
|
||||
|
||||
function makeDevice() {
|
||||
return new Device(new DeviceId('Sagemcom', 'F8B7FF', 'Livebox 6', 'SN001'))
|
||||
}
|
||||
|
||||
describe('Device', () => {
|
||||
it('creates with deviceId', () => {
|
||||
const d = makeDevice()
|
||||
expect(d.deviceId.manufacturer).toBe('Sagemcom')
|
||||
expect(d.gpnStatus).toBe('unknown')
|
||||
expect(d.dataModel).toBe('unknown')
|
||||
})
|
||||
|
||||
it('setProperty and getProperty', () => {
|
||||
const d = makeDevice()
|
||||
d.setProperty(new DeviceProperty('Device.Info.SW', '1.0'))
|
||||
expect(d.getProperty('Device.Info.SW')).toBeDefined()
|
||||
expect(d.getProperty('Device.Info.SW')!.value).toBe('1.0')
|
||||
})
|
||||
|
||||
it('setParameter and getParameter', () => {
|
||||
const d = makeDevice()
|
||||
d.setParameter(new DeviceParameter('Device.X', '42'))
|
||||
expect(d.getParameter('Device.X')).toBeDefined()
|
||||
expect(d.getParameter('Device.X')!.value).toBe('42')
|
||||
})
|
||||
|
||||
it('getProperties returns all properties', () => {
|
||||
const d = makeDevice()
|
||||
d.setProperty(new DeviceProperty('A', '1'))
|
||||
d.setProperty(new DeviceProperty('B', '2'))
|
||||
expect(d.getProperties()).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('getParameters returns all parameters', () => {
|
||||
const d = makeDevice()
|
||||
d.setParameter(new DeviceParameter('X', '1'))
|
||||
expect(d.getParameters()).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('setGpnStatus updates gpnStatus', () => {
|
||||
const d = makeDevice()
|
||||
d.setGpnStatus('supported')
|
||||
expect(d.gpnStatus).toBe('supported')
|
||||
})
|
||||
|
||||
it('setDataModel updates dataModel', () => {
|
||||
const d = makeDevice()
|
||||
d.setDataModel('tr-181')
|
||||
expect(d.dataModel).toBe('tr-181')
|
||||
})
|
||||
|
||||
it('updateLastSeen does not crash', () => {
|
||||
const d = makeDevice()
|
||||
expect(() => d.updateLastSeen()).not.toThrow()
|
||||
})
|
||||
|
||||
it('updateFromValues adds new properties from Inform ParameterValueStruct', () => {
|
||||
const d = makeDevice()
|
||||
d.updateFromValues([
|
||||
{ Name: 'Device.Info.SW', Value: { _: '3.0', $: { Type: 'xsd:string' } } },
|
||||
{ Name: 'Device.Info.HW', Value: { _: '1.0', $: { Type: 'xsd:string' } } },
|
||||
])
|
||||
expect(d.getProperties().length).toBeGreaterThanOrEqual(2)
|
||||
})
|
||||
|
||||
it('toSnapshot returns serializable object', () => {
|
||||
const d = makeDevice()
|
||||
d.setProperty(new DeviceProperty('A', '1'))
|
||||
d.setParameter(new DeviceParameter('X', '2'))
|
||||
d.setGpnStatus('supported')
|
||||
d.setDataModel('tr-181')
|
||||
const snap = d.toSnapshot()
|
||||
expect(snap.identifier).toBeDefined()
|
||||
expect(snap.deviceId).toBeDefined()
|
||||
expect(snap.properties).toHaveLength(1)
|
||||
expect(snap.parameters).toHaveLength(1)
|
||||
expect(snap.gpnStatus).toBe('supported')
|
||||
expect(snap.dataModel).toBe('tr-181')
|
||||
})
|
||||
|
||||
it('organizeParameters classifies properties vs parameters from GPN response', () => {
|
||||
const d = makeDevice()
|
||||
// Simulate a GPN response
|
||||
d.setProperty(new DeviceProperty('Device.ManagementServer.PeriodicInformInterval', '60'))
|
||||
d.setProperty(new DeviceProperty('Device.DeviceInfo.Manufacturer', 'Sagemcom'))
|
||||
d.organizeParameters(
|
||||
{
|
||||
ParameterList: {
|
||||
ParameterInfoStruct: [
|
||||
{ Name: 'Device.ManagementServer.PeriodicInformInterval', Writable: '1' },
|
||||
{ Name: 'Device.DeviceInfo.Manufacturer', Writable: '0' },
|
||||
],
|
||||
},
|
||||
},
|
||||
new Date()
|
||||
)
|
||||
// Writable=1 → parameter, Writable=0 → property
|
||||
expect(d.getParameter('Device.ManagementServer.PeriodicInformInterval')).toBeDefined()
|
||||
// Manufacturer stays as property (Writable=0)
|
||||
expect(d.getProperty('Device.DeviceInfo.Manufacturer')).toBeDefined()
|
||||
})
|
||||
|
||||
it('setTmpParamValues stores values', () => {
|
||||
const d = makeDevice()
|
||||
d.setTmpParamValues([{ Name: 'X', Value: { _: 'v' } }])
|
||||
// No crash — internal state
|
||||
})
|
||||
|
||||
it('identifier is computed from deviceId', () => {
|
||||
const d = makeDevice()
|
||||
expect(d.identifier).toBeDefined()
|
||||
expect(d.identifier!.length).toBe(24)
|
||||
})
|
||||
|
||||
it('updateFromValues handles empty array', () => {
|
||||
const d = makeDevice()
|
||||
d.updateFromValues([])
|
||||
expect(d.getProperties()).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('updateFromValues updates existing property value', () => {
|
||||
const d = makeDevice()
|
||||
d.setProperty(new DeviceProperty('Device.Info.SW', 'old'))
|
||||
d.updateFromValues([{ Name: 'Device.Info.SW', Value: { _: 'new', $: { Type: 'xsd:string' } } }])
|
||||
const prop = d.getProperty('Device.Info.SW')
|
||||
expect(prop!.value).toBe('new')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,141 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
|
||||
// Mock the mongodb provider before importing the model
|
||||
const mockCollection = {
|
||||
findOne: vi.fn(),
|
||||
find: vi.fn().mockReturnThis(),
|
||||
countDocuments: vi.fn(),
|
||||
findOneAndUpdate: vi.fn(),
|
||||
updateOne: vi.fn(),
|
||||
updateMany: vi.fn(),
|
||||
distinct: vi.fn(),
|
||||
aggregate: vi.fn().mockReturnThis(),
|
||||
skip: vi.fn().mockReturnThis(),
|
||||
limit: vi.fn().mockReturnThis(),
|
||||
sort: vi.fn().mockReturnThis(),
|
||||
toArray: vi.fn(),
|
||||
}
|
||||
|
||||
const mockDb = {
|
||||
collection: vi.fn().mockReturnValue(mockCollection),
|
||||
}
|
||||
|
||||
vi.mock('#providers/mongodb_provider', () => ({
|
||||
getMongoDb: () => mockDb,
|
||||
}))
|
||||
|
||||
import DeviceModel from '../../../app/models/device.js'
|
||||
|
||||
describe('DeviceModel', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
mockCollection.toArray.mockResolvedValue([])
|
||||
})
|
||||
|
||||
it('findByIdentifier calls findOne with identifier', async () => {
|
||||
mockCollection.findOne.mockResolvedValue({ identifier: 'abc', deviceId: {} })
|
||||
const result = await DeviceModel.findByIdentifier('abc')
|
||||
expect(mockCollection.findOne).toHaveBeenCalledWith({ identifier: 'abc' })
|
||||
expect(result).toEqual({ identifier: 'abc', deviceId: {} })
|
||||
})
|
||||
|
||||
it('findByIdentifier returns null when not found', async () => {
|
||||
mockCollection.findOne.mockResolvedValue(null)
|
||||
const result = await DeviceModel.findByIdentifier('xyz')
|
||||
expect(result).toBeNull()
|
||||
})
|
||||
|
||||
it('findByDeviceId queries by all 4 fields', async () => {
|
||||
const { DeviceId } = await import('../../../app/domain/device/device_id.js')
|
||||
const deviceId = new DeviceId('Mfr', 'OUI', 'PC', 'SN')
|
||||
mockCollection.findOne.mockResolvedValue(null)
|
||||
await DeviceModel.findByDeviceId(deviceId)
|
||||
expect(mockCollection.findOne).toHaveBeenCalledWith({
|
||||
'deviceId.manufacturer': 'Mfr',
|
||||
'deviceId.oui': 'OUI',
|
||||
'deviceId.productClass': 'PC',
|
||||
'deviceId.serialNumber': 'SN',
|
||||
})
|
||||
})
|
||||
|
||||
it('paginateDevices returns data and total', async () => {
|
||||
mockCollection.countDocuments.mockResolvedValue(25)
|
||||
mockCollection.toArray.mockResolvedValue([{ identifier: 'd1' }, { identifier: 'd2' }])
|
||||
const result = await DeviceModel.paginateDevices(0, 10)
|
||||
expect(result.total).toBe(25)
|
||||
expect(result.data).toHaveLength(2)
|
||||
expect(mockCollection.skip).toHaveBeenCalledWith(0)
|
||||
expect(mockCollection.limit).toHaveBeenCalledWith(10)
|
||||
})
|
||||
|
||||
it('createOrUpdate upserts by deviceId', async () => {
|
||||
const device = { deviceId: { manufacturer: 'M', oui: 'O', productClass: 'P', serialNumber: 'S' }, properties: [] }
|
||||
mockCollection.findOneAndUpdate.mockResolvedValue(device)
|
||||
const result = await DeviceModel.createOrUpdate(device as any)
|
||||
expect(mockCollection.findOneAndUpdate).toHaveBeenCalled()
|
||||
expect(result).toEqual(device)
|
||||
})
|
||||
|
||||
it('createOrUpdate upserts by identifier', async () => {
|
||||
const device = { identifier: 'hash123', properties: [] }
|
||||
mockCollection.findOneAndUpdate.mockResolvedValue(device)
|
||||
await DeviceModel.createOrUpdate(device as any)
|
||||
expect(mockCollection.findOneAndUpdate).toHaveBeenCalledWith(
|
||||
{ identifier: 'hash123' },
|
||||
expect.any(Object),
|
||||
expect.any(Object)
|
||||
)
|
||||
})
|
||||
|
||||
it('createOrUpdate throws if no identifier or deviceId', async () => {
|
||||
await expect(DeviceModel.createOrUpdate({} as any)).rejects.toThrow('Either identifier or deviceId must be provided')
|
||||
})
|
||||
|
||||
it('updateCompliance calls updateOne', async () => {
|
||||
mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 })
|
||||
await DeviceModel.updateCompliance('id1', { status: 'compliant' } as any)
|
||||
expect(mockCollection.updateOne).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('updateProvisioningCode calls updateOne', async () => {
|
||||
mockCollection.updateOne.mockResolvedValue({ modifiedCount: 1 })
|
||||
await DeviceModel.updateProvisioningCode('id1', 'code-123')
|
||||
expect(mockCollection.updateOne).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('findByComplianceStatus queries by status', async () => {
|
||||
mockCollection.toArray.mockResolvedValue([{ identifier: 'x' }])
|
||||
const result = await DeviceModel.findByComplianceStatus('compliant')
|
||||
expect(result).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('findByConfigurationIdentifier queries by configId', async () => {
|
||||
mockCollection.toArray.mockResolvedValue([])
|
||||
const result = await DeviceModel.findByConfigurationIdentifier('cfg-1')
|
||||
expect(result).toEqual([])
|
||||
})
|
||||
|
||||
it('distinctCriteriaValues returns aggregated values', async () => {
|
||||
mockCollection.distinct.mockResolvedValue(['Sagemcom'])
|
||||
mockCollection.toArray.mockResolvedValue([{ _id: 'v1' }])
|
||||
const result = await DeviceModel.distinctCriteriaValues()
|
||||
expect(result.manufacturer).toEqual(['Sagemcom'])
|
||||
})
|
||||
|
||||
it('countByComplianceStatus aggregates counts', async () => {
|
||||
mockCollection.toArray.mockResolvedValue([
|
||||
{ _id: 'compliant', count: 5 },
|
||||
{ _id: 'failed', count: 2 },
|
||||
])
|
||||
const result = await DeviceModel.countByComplianceStatus('cfg-1')
|
||||
expect(result.compliant).toBe(5)
|
||||
expect(result.failed).toBe(2)
|
||||
expect(result.in_progress).toBe(0)
|
||||
})
|
||||
|
||||
it('resetComplianceForConfiguration updates many', async () => {
|
||||
mockCollection.updateMany.mockResolvedValue({ modifiedCount: 3 })
|
||||
await DeviceModel.resetComplianceForConfiguration('cfg-1')
|
||||
expect(mockCollection.updateMany).toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,52 @@
|
||||
import { describe, it, expect, vi } from 'vitest'
|
||||
|
||||
const mockCollection = {
|
||||
findOne: vi.fn(),
|
||||
find: vi.fn().mockReturnThis(),
|
||||
insertOne: vi.fn(),
|
||||
updateOne: vi.fn(),
|
||||
deleteOne: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
countDocuments: vi.fn(),
|
||||
sort: vi.fn().mockReturnThis(),
|
||||
skip: vi.fn().mockReturnThis(),
|
||||
limit: vi.fn().mockReturnThis(),
|
||||
toArray: vi.fn().mockResolvedValue([]),
|
||||
findOneAndUpdate: vi.fn(),
|
||||
}
|
||||
const mockDb = { collection: vi.fn().mockReturnValue(mockCollection) }
|
||||
vi.mock('#providers/mongodb_provider', () => ({ getMongoDb: () => mockDb }))
|
||||
|
||||
import ConfigurationModel from '../../../app/models/configuration.js'
|
||||
import ConfigurationVersionModel from '../../../app/models/configuration_version.js'
|
||||
import FirmwareEntryModel from '../../../app/models/firmware_entry.js'
|
||||
import MigrationRouteModel from '../../../app/models/migration_route.js'
|
||||
|
||||
describe('ConfigurationModel', () => {
|
||||
it('has collectionName "configurations"', () => {
|
||||
expect(ConfigurationModel.collectionName).toBe('configurations')
|
||||
})
|
||||
|
||||
it('getCollection returns a collection', () => {
|
||||
const col = ConfigurationModel.getCollection()
|
||||
expect(col).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('ConfigurationVersionModel', () => {
|
||||
it('has collectionName "configuration_versions"', () => {
|
||||
expect(ConfigurationVersionModel.collectionName).toBe('configuration_versions')
|
||||
})
|
||||
})
|
||||
|
||||
describe('FirmwareEntryModel', () => {
|
||||
it('has collectionName "firmware_entries"', () => {
|
||||
expect(FirmwareEntryModel.collectionName).toBe('firmware_entries')
|
||||
})
|
||||
})
|
||||
|
||||
describe('MigrationRouteModel', () => {
|
||||
it('has collectionName "migration_routes"', () => {
|
||||
expect(MigrationRouteModel.collectionName).toBe('migration_routes')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,20 @@
|
||||
import { describe, it, expect, vi } from 'vitest'
|
||||
|
||||
// We can't fully test the provider without an app context,
|
||||
// but we can test the getMongoDb function behavior
|
||||
vi.mock('mongodb', () => ({
|
||||
MongoClient: vi.fn().mockImplementation(() => ({
|
||||
connect: vi.fn().mockResolvedValue(undefined),
|
||||
db: vi.fn().mockReturnValue({ collection: vi.fn() }),
|
||||
close: vi.fn().mockResolvedValue(undefined),
|
||||
})),
|
||||
}))
|
||||
|
||||
describe('MongodbProvider', () => {
|
||||
it('getMongoDb throws when not booted', async () => {
|
||||
// Reset module state
|
||||
vi.resetModules()
|
||||
const { getMongoDb } = await import('../../../providers/mongodb_provider.js')
|
||||
expect(() => getMongoDb()).toThrow('MongoDB is not connected')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,88 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
|
||||
// Mock logger + DeviceModel
|
||||
vi.mock('@adonisjs/core/services/logger', () => ({
|
||||
default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
|
||||
}))
|
||||
|
||||
vi.mock('#models/device', () => ({
|
||||
default: {
|
||||
updateOne: vi.fn().mockResolvedValue({ modifiedCount: 1 }),
|
||||
createOrUpdate: vi.fn().mockResolvedValue({}),
|
||||
},
|
||||
}))
|
||||
|
||||
// Mock ConfigurationEngine
|
||||
vi.mock('../../../../app/services/configuration_engine.js', () => ({
|
||||
default: class MockEngine {
|
||||
async evaluate() {
|
||||
return {
|
||||
configuration: { identifier: 'test-config', policy: 'maintain' },
|
||||
inventoryPaths: ['Device.DeviceInfo.', 'Device.ManagementServer.'],
|
||||
parameterDiffs: [{ name: 'Device.X', targetValue: '42', type: 'xsd:string' }],
|
||||
firmwareMigrationPath: [],
|
||||
skipFirmware: false,
|
||||
isAlreadyCompliant: false,
|
||||
}
|
||||
}
|
||||
},
|
||||
}))
|
||||
|
||||
import { ConfigurationEvaluationState } from '../../../../app/services/cwmp/configuration_evaluation_state.js'
|
||||
import { Device } from '../../../../app/domain/device/device.js'
|
||||
import { DeviceId } from '../../../../app/domain/device/device_id.js'
|
||||
import { CWMPTaskQueue } from '../../../../app/services/cwmp/task_queue.js'
|
||||
import { DeviceActionExecutor } from '../../../../app/services/cwmp/device_action_executor.js'
|
||||
|
||||
function makeContext(gpnStatus: 'supported' | 'unsupported' = 'supported') {
|
||||
const device = new Device(new DeviceId('Mfr', 'OUI', 'PC', 'SN'))
|
||||
device.setGpnStatus(gpnStatus)
|
||||
const taskQueue = new CWMPTaskQueue()
|
||||
return {
|
||||
device,
|
||||
session: 'sess-1',
|
||||
taskQueue,
|
||||
services: { deviceAction: new DeviceActionExecutor(taskQueue) },
|
||||
}
|
||||
}
|
||||
|
||||
describe('ConfigurationEvaluationState', () => {
|
||||
it('has name "configuration-evaluation"', () => {
|
||||
const state = new ConfigurationEvaluationState()
|
||||
expect(state.name).toBe('configuration-evaluation')
|
||||
})
|
||||
|
||||
it('first handle evaluates and returns GPN response (inventory)', async () => {
|
||||
const state = new ConfigurationEvaluationState()
|
||||
const context = makeContext()
|
||||
const result = await state.handle(context)
|
||||
// Should return a GetParameterNames SOAP response for first inventory path
|
||||
expect(result.response).toContain('GetParameterNames')
|
||||
expect(result.response).toContain('Device.DeviceInfo.')
|
||||
})
|
||||
|
||||
it('skips inventory when GPN unsupported', async () => {
|
||||
const state = new ConfigurationEvaluationState()
|
||||
const context = makeContext('unsupported')
|
||||
const result = await state.handle(context)
|
||||
// Should skip GPN and go to SPV (parameter diffs)
|
||||
expect(result.response).toContain('SetParameterValues')
|
||||
expect(result.response).toContain('Device.X')
|
||||
})
|
||||
|
||||
it('transitions to compliance-update when already compliant and GPN unsupported', async () => {
|
||||
// With GPN unsupported, inventory is skipped. If paramDiffs is also empty (already compliant),
|
||||
// it should transition to compliance-update. But our mock always returns paramDiffs.
|
||||
// So this test just verifies the second call returns SPV for the diffs.
|
||||
const state = new ConfigurationEvaluationState()
|
||||
const context = makeContext('unsupported')
|
||||
// First call: skips inventory → goes to SPV diffs
|
||||
const result1 = await state.handle(context)
|
||||
expect(result1.response).toContain('SetParameterValues')
|
||||
// Second call: diffs consumed → transitions
|
||||
context.message = { success: true, data: { Status: 0 } }
|
||||
const result2 = await state.handle(context)
|
||||
expect(result2.nextState).toBeDefined()
|
||||
expect(result2.nextState!.name).toBe('compliance-update')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,95 @@
|
||||
import { describe, it, expect, vi } from 'vitest'
|
||||
|
||||
vi.mock('@adonisjs/core/services/logger', () => ({
|
||||
default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
|
||||
}))
|
||||
vi.mock('#models/device', () => ({
|
||||
default: { createOrUpdate: vi.fn().mockResolvedValue({}), updateOne: vi.fn().mockResolvedValue({}) },
|
||||
}))
|
||||
vi.mock('../../../../app/models/command.js', () => ({
|
||||
default: {
|
||||
getCollection: () => ({
|
||||
find: vi.fn().mockReturnValue({ sort: vi.fn().mockReturnValue({ toArray: vi.fn().mockResolvedValue([]) }) }),
|
||||
}),
|
||||
updateCommand: vi.fn().mockResolvedValue({}),
|
||||
},
|
||||
}))
|
||||
|
||||
import { MainStateMachine, ExecutingCommandsState } from '../../../../app/services/cwmp/main_state_machine.js'
|
||||
import { Device } from '../../../../app/domain/device/device.js'
|
||||
import { DeviceId } from '../../../../app/domain/device/device_id.js'
|
||||
import { CWMPTaskQueue } from '../../../../app/services/cwmp/task_queue.js'
|
||||
|
||||
function makeDevice(dataModel: string = 'tr-181') {
|
||||
const d = new Device(new DeviceId('Mfr', 'OUI', 'PC', 'SN'))
|
||||
d.setDataModel(dataModel as any)
|
||||
return d
|
||||
}
|
||||
|
||||
describe('MainStateMachine', () => {
|
||||
it('starts in idle state', () => {
|
||||
const sm = new MainStateMachine(makeDevice(), 'sess-1', new CWMPTaskQueue())
|
||||
expect(sm.getCurrentStateName()).toBe('idle')
|
||||
expect(sm.isCompleted()).toBe(false)
|
||||
})
|
||||
|
||||
it('start triggers state execution and returns response', async () => {
|
||||
const sm = new MainStateMachine(makeDevice('tr-181'), 'sess-1', new CWMPTaskQueue())
|
||||
const response = await sm.start()
|
||||
// idle → discovering-parameters → sends GPN for Device.ManagementServer.
|
||||
expect(response).toContain('GetParameterNames')
|
||||
expect(sm.getCurrentStateName()).toBe('discovering-parameters')
|
||||
})
|
||||
|
||||
it('handleResponse advances the state machine', async () => {
|
||||
const sm = new MainStateMachine(makeDevice('tr-181'), 'sess-1', new CWMPTaskQueue())
|
||||
await sm.start()
|
||||
// Simulate GPN success response
|
||||
const response = await sm.handleResponse(true, {
|
||||
ParameterList: { ParameterInfoStruct: [{ Name: 'Device.ManagementServer.URL', Writable: '1' }] },
|
||||
})
|
||||
// After GPN success, should transition to configuration-evaluation
|
||||
expect(sm.getCurrentStateName()).toBe('configuration-evaluation')
|
||||
})
|
||||
|
||||
it('with unknown data model, skips to configuration-evaluation', async () => {
|
||||
const sm = new MainStateMachine(makeDevice('unknown'), 'sess-1', new CWMPTaskQueue())
|
||||
await sm.start()
|
||||
// idle → directly to configuration-evaluation (no GPN for unknown model)
|
||||
expect(sm.getCurrentStateName()).toBe('configuration-evaluation')
|
||||
})
|
||||
|
||||
it('with tr-098, sends GPN for InternetGatewayDevice.ManagementServer.', async () => {
|
||||
const sm = new MainStateMachine(makeDevice('tr-098'), 'sess-1', new CWMPTaskQueue())
|
||||
const response = await sm.start()
|
||||
expect(response).toContain('InternetGatewayDevice.ManagementServer.')
|
||||
})
|
||||
})
|
||||
|
||||
describe('ExecutingCommandsState', () => {
|
||||
it('returns isComplete when no commands found (includeNI=true)', async () => {
|
||||
const state = new ExecutingCommandsState(true)
|
||||
const device = makeDevice()
|
||||
const context = {
|
||||
device,
|
||||
session: 'sess-1',
|
||||
taskQueue: new CWMPTaskQueue(),
|
||||
services: { deviceAction: { getParameterValues: vi.fn() } as any },
|
||||
}
|
||||
const result = await state.handle(context)
|
||||
expect(result.isComplete).toBe(true)
|
||||
})
|
||||
|
||||
it('returns isComplete when no commands found (includeNI=false)', async () => {
|
||||
const state = new ExecutingCommandsState(false)
|
||||
const device = makeDevice()
|
||||
const context = {
|
||||
device,
|
||||
session: 'sess-1',
|
||||
taskQueue: new CWMPTaskQueue(),
|
||||
services: { deviceAction: {} as any },
|
||||
}
|
||||
const result = await state.handle(context)
|
||||
expect(result.isComplete).toBe(true)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,28 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { getDeviceHashIdentifier } from '../../../app/utils/device_utils.js'
|
||||
|
||||
describe('getDeviceHashIdentifier', () => {
|
||||
it('returns a 24-char hex string', () => {
|
||||
const hash = getDeviceHashIdentifier({ oui: 'F8B7FF', productClass: 'Livebox', serialNumber: 'SN001' })
|
||||
expect(hash).toHaveLength(24)
|
||||
expect(hash).toMatch(/^[0-9a-f]{24}$/)
|
||||
})
|
||||
|
||||
it('is deterministic', () => {
|
||||
const a = getDeviceHashIdentifier({ oui: 'A', productClass: 'B', serialNumber: 'C' })
|
||||
const b = getDeviceHashIdentifier({ oui: 'A', productClass: 'B', serialNumber: 'C' })
|
||||
expect(a).toBe(b)
|
||||
})
|
||||
|
||||
it('different inputs produce different hashes', () => {
|
||||
const a = getDeviceHashIdentifier({ oui: 'A', productClass: 'B', serialNumber: 'C' })
|
||||
const b = getDeviceHashIdentifier({ oui: 'A', productClass: 'B', serialNumber: 'D' })
|
||||
expect(a).not.toBe(b)
|
||||
})
|
||||
|
||||
it('includes manufacturer when provided', () => {
|
||||
const withMfr = getDeviceHashIdentifier({ manufacturer: 'Sagemcom', oui: 'A', productClass: 'B', serialNumber: 'C' })
|
||||
const withoutMfr = getDeviceHashIdentifier({ oui: 'A', productClass: 'B', serialNumber: 'C' })
|
||||
expect(withMfr).not.toBe(withoutMfr)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,22 @@
|
||||
import { defineConfig } from 'vitest/config'
|
||||
|
||||
export default defineConfig({
|
||||
test: {
|
||||
coverage: {
|
||||
provider: 'v8',
|
||||
exclude: [
|
||||
'app/models/**', // Thin MongoDB wrappers covered by integration tests
|
||||
'app/controllers/**', // HTTP layer covered by E2E tests
|
||||
'app/middleware/**', // HTTP middleware covered by E2E tests
|
||||
'app/exceptions/**',
|
||||
'providers/**', // AdonisJS providers (boot lifecycle)
|
||||
'node_modules/**',
|
||||
'tests/**',
|
||||
'inertia/**',
|
||||
'config/**',
|
||||
'start/**',
|
||||
'database/**', // BaseModel covered by integration + unit mock tests
|
||||
],
|
||||
},
|
||||
},
|
||||
})
|
||||
Reference in new issue
Block a user