241 lines
8.7 KiB
TypeScript
241 lines
8.7 KiB
TypeScript
// Unit tests for the extracted licensing policy/entitlement rules and for LicenseService running
|
|
// against an injected in-memory store (including files written before the key/cloud split).
|
|
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { Feature } from '@d3ro/core/types'
|
|
import type { LicenseVerificationResult } from '@d3ro/core/utils/crypto-license'
|
|
import { generateLicenseKeyPair, issueSignedLicenseKey } from '@d3ro/core/utils/crypto-license'
|
|
import {
|
|
higherTier,
|
|
quotaLimitFor,
|
|
tierAtLeast,
|
|
upgradeTargetFor,
|
|
buildTierComparison,
|
|
} from '../../../src/main/services/license/license-policy'
|
|
import {
|
|
composeLicenseInfo,
|
|
resolveCachedCloudTier,
|
|
resolveStoredKey,
|
|
type StoredKeyRecord,
|
|
} from '../../../src/main/services/license/license-entitlement'
|
|
import { MemoryLicenseStore } from '../../../src/main/services/license/license-store'
|
|
import type { UsageRepository } from '../../../src/main/services/license/usage-repository'
|
|
import { LicenseService } from '../../../src/main/services/LicenseService'
|
|
|
|
const DAY_MS = 24 * 60 * 60 * 1000
|
|
const T0 = new Date('2026-03-01T00:00:00Z').getTime()
|
|
|
|
const EMPTY_RECORD: StoredKeyRecord = {
|
|
licenseKey: null,
|
|
keyTier: null,
|
|
activatedAt: null,
|
|
customerEmail: null,
|
|
trialExpiresAt: null,
|
|
}
|
|
|
|
function verification(overrides: Partial<LicenseVerificationResult>): LicenseVerificationResult {
|
|
return { valid: true, tier: 'pro', reason: 'valid', payload: null, message: 'ok', ...overrides }
|
|
}
|
|
|
|
const noUsage: UsageRepository = { getCount: () => 0, increment: () => undefined }
|
|
|
|
describe('license-policy', () => {
|
|
it('orders tiers and picks the higher one', () => {
|
|
expect(tierAtLeast('pro_plus', 'pro')).toBe(true)
|
|
expect(tierAtLeast('free', 'pro')).toBe(false)
|
|
expect(higherTier('pro', 'free')).toBe('pro')
|
|
expect(higherTier('free', 'pro_plus')).toBe('pro_plus')
|
|
expect(higherTier('team', 'pro')).toBe('team')
|
|
})
|
|
|
|
it('suggests the next paid tier on quota exhaustion', () => {
|
|
expect(upgradeTargetFor('free')).toBe('pro')
|
|
expect(upgradeTargetFor('pro')).toBe('pro_plus')
|
|
})
|
|
|
|
it('only PREMIUM_LLM carries a quota and local features stay unlimited', () => {
|
|
expect(quotaLimitFor('free', Feature.DICTATION)).toBeUndefined()
|
|
expect(typeof quotaLimitFor('free', Feature.PREMIUM_LLM)).toBe('number')
|
|
})
|
|
|
|
it('returns a fresh comparison table per call', () => {
|
|
const a = buildTierComparison()
|
|
const b = buildTierComparison()
|
|
expect(a).toEqual(b)
|
|
expect(a).not.toBe(b)
|
|
expect(a).toHaveLength(17)
|
|
})
|
|
})
|
|
|
|
describe('license-entitlement.resolveStoredKey', () => {
|
|
it('returns none without a stored key', () => {
|
|
expect(resolveStoredKey(EMPTY_RECORD, T0, () => verification({})).status).toBe('none')
|
|
})
|
|
|
|
it('re-verifies a signed key instead of applying a grace window', () => {
|
|
const verify = vi.fn(() => verification({ tier: 'pro_plus', payload: null }))
|
|
const res = resolveStoredKey({ ...EMPTY_RECORD, licenseKey: 'D3RO-LIC-x', activatedAt: 1 }, T0, verify)
|
|
expect(verify).toHaveBeenCalledWith('D3RO-LIC-x')
|
|
expect(res).toMatchObject({ status: 'active', entitlement: { tier: 'pro_plus', activatedAt: 1 } })
|
|
})
|
|
|
|
it('reports a key whose own expiry passed as expired', () => {
|
|
const res = resolveStoredKey({ ...EMPTY_RECORD, licenseKey: 'D3RO-LIC-x' }, T0, () =>
|
|
verification({ valid: false, reason: 'expired', tier: 'free' }),
|
|
)
|
|
expect(res).toEqual({ status: 'expired', kind: 'license' })
|
|
})
|
|
|
|
it('reports other verification failures as unverified (the key is kept)', () => {
|
|
const res = resolveStoredKey({ ...EMPTY_RECORD, licenseKey: 'D3RO-LIC-x' }, T0, () =>
|
|
verification({ valid: false, reason: 'invalid_signature', tier: 'free', message: 'no key' }),
|
|
)
|
|
expect(res).toEqual({ status: 'unverified', message: 'no key' })
|
|
})
|
|
|
|
it('handles the local reverse trial by its own expiry without calling the verifier', () => {
|
|
const verify = vi.fn(() => verification({}))
|
|
const record = { ...EMPTY_RECORD, licenseKey: 'TRIAL-PRO-PLUS-abc', trialExpiresAt: T0 + DAY_MS }
|
|
expect(resolveStoredKey(record, T0, verify)).toMatchObject({
|
|
status: 'active',
|
|
entitlement: { tier: 'pro_plus', isTrial: true },
|
|
})
|
|
expect(resolveStoredKey(record, T0 + 2 * DAY_MS, verify)).toEqual({ status: 'expired', kind: 'trial' })
|
|
expect(verify).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe('license-entitlement.resolveCachedCloudTier', () => {
|
|
const activePro = {
|
|
status: 'active' as const,
|
|
entitlement: {
|
|
tier: 'pro' as const,
|
|
licenseKey: 'k',
|
|
activatedAt: null,
|
|
expiresAt: null,
|
|
customerEmail: null,
|
|
isTrial: false,
|
|
trialExpiresAt: null,
|
|
},
|
|
}
|
|
|
|
it('prefers the explicitly stored cloud tier', () => {
|
|
expect(resolveCachedCloudTier('pro', 'free', { status: 'none' })).toBe('pro')
|
|
})
|
|
|
|
it('recovers a legacy cloud tier only when no key explains it', () => {
|
|
expect(resolveCachedCloudTier(null, 'pro', { status: 'none' })).toBe('pro')
|
|
expect(resolveCachedCloudTier(null, 'pro', activePro)).toBe('free')
|
|
expect(resolveCachedCloudTier(null, 'pro_plus', activePro)).toBe('pro_plus')
|
|
expect(resolveCachedCloudTier(null, 'pro', { status: 'unverified', message: '' })).toBe('free')
|
|
expect(resolveCachedCloudTier(null, null, { status: 'none' })).toBe('free')
|
|
})
|
|
|
|
it('composes the effective tier as max(key, cloud)', () => {
|
|
const info = composeLicenseInfo({
|
|
machineId: 'm',
|
|
key: activePro.entitlement,
|
|
keyVerifiedAt: 5,
|
|
cloudTier: 'free',
|
|
cloudVerifiedAt: 9,
|
|
})
|
|
expect(info.tier).toBe('pro')
|
|
expect(info.lastVerifiedAt).toBe(9)
|
|
expect(info.offlineGraceUntil).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('LicenseService with an injected store', () => {
|
|
let previousPublicKey: string | undefined
|
|
let signedKey = ''
|
|
|
|
beforeEach(() => {
|
|
previousPublicKey = process.env.D3RO_LICENSE_PUBLIC_KEY
|
|
vi.useFakeTimers()
|
|
vi.setSystemTime(T0)
|
|
const { publicKeyPem, privateKeyPem } = generateLicenseKeyPair()
|
|
process.env.D3RO_LICENSE_PUBLIC_KEY = publicKeyPem
|
|
signedKey = issueSignedLicenseKey(
|
|
{
|
|
licenseId: 'lic-legacy',
|
|
tier: 'pro',
|
|
customerEmail: 'legacy@example.test',
|
|
issuedAt: T0 - 90 * DAY_MS,
|
|
expiresAt: T0 + 275 * DAY_MS,
|
|
machineId: null,
|
|
},
|
|
privateKeyPem,
|
|
)
|
|
})
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers()
|
|
if (previousPublicKey === undefined) delete process.env.D3RO_LICENSE_PUBLIC_KEY
|
|
else process.env.D3RO_LICENSE_PUBLIC_KEY = previousPublicKey
|
|
})
|
|
|
|
it('restores a legacy file whose 30-day grace already ran out', () => {
|
|
const store = new MemoryLicenseStore()
|
|
store.writeAll({
|
|
licenseTier: 'pro',
|
|
licenseKey: signedKey,
|
|
licenseActivatedAt: T0 - 90 * DAY_MS,
|
|
licenseOfflineGraceUntil: T0 - 60 * DAY_MS,
|
|
})
|
|
const svc = new LicenseService(store, noUsage)
|
|
svc.initialize()
|
|
expect(svc.tier).toBe('pro')
|
|
expect(svc.getInfo().licenseKey).toBe(signedKey)
|
|
expect(store.read('licenseCloudTier')).toBe('free')
|
|
})
|
|
|
|
it('restores a key that a free cloud sync had hidden in a legacy file', () => {
|
|
const store = new MemoryLicenseStore()
|
|
store.writeAll({ licenseTier: 'free', licenseKey: signedKey })
|
|
const svc = new LicenseService(store, noUsage)
|
|
svc.initialize()
|
|
expect(svc.tier).toBe('pro')
|
|
expect(store.read('licenseTier')).toBe('pro')
|
|
})
|
|
|
|
it('keeps a legacy cached cloud tier until sign-out', () => {
|
|
const store = new MemoryLicenseStore()
|
|
store.writeAll({ licenseTier: 'pro_plus', licenseLastVerifiedAt: T0 - DAY_MS })
|
|
const svc = new LicenseService(store, noUsage)
|
|
svc.initialize()
|
|
expect(svc.tier).toBe('pro_plus')
|
|
expect(svc.getInfo().lastVerifiedAt).toBe(T0 - DAY_MS)
|
|
svc.resetToFree()
|
|
expect(svc.tier).toBe('free')
|
|
expect(store.read('licenseCloudTier')).toBe('free')
|
|
})
|
|
|
|
it('keeps a legacy reverse trial until its expiry', () => {
|
|
const store = new MemoryLicenseStore()
|
|
store.writeAll({
|
|
licenseTier: 'pro_plus',
|
|
licenseKey: 'TRIAL-PRO-PLUS-abcdef12',
|
|
licenseIsTrial: true,
|
|
licenseTrialExpiresAt: T0 + 3 * DAY_MS,
|
|
licenseTrialEverStarted: true,
|
|
})
|
|
const svc = new LicenseService(store, noUsage)
|
|
svc.initialize()
|
|
expect(svc.tier).toBe('pro_plus')
|
|
expect(svc.getInfo().isTrial).toBe(true)
|
|
|
|
vi.setSystemTime(T0 + 4 * DAY_MS)
|
|
svc.initialize()
|
|
expect(svc.tier).toBe('free')
|
|
expect(store.read('licenseKey')).toBeNull()
|
|
expect(store.read('licenseTrialEverStarted')).toBe(true)
|
|
})
|
|
|
|
it('records quota usage through the injected repository', () => {
|
|
const increment = vi.fn()
|
|
const svc = new LicenseService(new MemoryLicenseStore(), { getCount: () => 0, increment })
|
|
svc.initialize()
|
|
svc.consumeQuota(Feature.DICTATION)
|
|
expect(increment).not.toHaveBeenCalled()
|
|
})
|
|
})
|