@ufdevsllc/authme2.0/lib/__tests__/models/license.test.js

SDK for license management and remote monitoring with automatic system tracking, license validation, and remote control capabilities

import mongoose from 'mongoose';
import License from '../../models/license.js';

describe('License Model', () => {
    beforeAll(async () => {
        // Connect to test database
        await mongoose.connect('mongodb://localhost:27017/test-license-sdk-license');
        // Ensure indexes are created
        await License.createIndexes();
    });

    afterAll(async () => {
        await mongoose.connection.dropDatabase();
        await mongoose.connection.close();
    });

    beforeEach(async () => {
        await License.deleteMany({});
    });

    describe('Schema Validation', () => {
        const validLicenseData = {
            licenseKey: 'TEST-LICENSE-KEY-123',
            distributionLimit: 5,
            vendorId: 'vendor123',
            productId: 'product456',
            expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days from now
        };

        test('should create a valid license', async () => {
            const license = new License(validLicenseData);
            const savedLicense = await license.save();

            expect(savedLicense._id).toBeDefined();
            expect(savedLicense.licenseKey).toBe(validLicenseData.licenseKey);
            expect(savedLicense.distributionLimit).toBe(validLicenseData.distributionLimit);
            expect(savedLicense.currentDistributions).toBe(0);
            expect(savedLicense.isActive).toBe(true);
            expect(savedLicense.vendorId).toBe(validLicenseData.vendorId);
            expect(savedLicense.productId).toBe(validLicenseData.productId);
        });

        test('should require licenseKey', async () => {
            const license = new License({ ...validLicenseData, licenseKey: undefined });

            await expect(license.save()).rejects.toThrow('License key is required');
        });

        test('should require unique licenseKey', async () => {
            const license1 = new License(validLicenseData);
            await license1.save();

            const license2 = new License(validLicenseData);
            await expect(license2.save()).rejects.toThrow();
        });

        test('should validate licenseKey length', async () => {
            const shortKey = new License({ ...validLicenseData, licenseKey: '123' });
            await expect(shortKey.save()).rejects.toThrow('License key must be at least 10 characters long');

            const longKey = new License({
                ...validLicenseData,
                licenseKey: 'a'.repeat(101)
            });
            await expect(longKey.save()).rejects.toThrow('License key cannot exceed 100 characters');
        });

        test('should require distributionLimit', async () => {
            const license = new License({ ...validLicenseData, distributionLimit: undefined });

            await expect(license.save()).rejects.toThrow('Distribution limit is required');
        });

        test('should validate distributionLimit range', async () => {
            const lowLimit = new License({ ...validLicenseData, distributionLimit: 0 });
            await expect(lowLimit.save()).rejects.toThrow('Distribution limit must be at least 1');

            const highLimit = new License({ ...validLicenseData, distributionLimit: 10001 });
            await expect(highLimit.save()).rejects.toThrow('Distribution limit cannot exceed 10000');
        });

        test('should validate currentDistributions does not exceed distributionLimit', async () => {
            const license = new License({
                ...validLicenseData,
                distributionLimit: 5,
                currentDistributions: 6
            });

            await expect(license.save()).rejects.toThrow('Current distributions cannot exceed distribution limit');
        });

        test('should require expiresAt', async () => {
            const license = new License({ ...validLicenseData, expiresAt: undefined });

            await expect(license.save()).rejects.toThrow('Expiration date is required');
        });

        test('should validate expiresAt is after createdAt', async () => {
            const pastDate = new Date(Date.now() - 24 * 60 * 60 * 1000); // Yesterday
            const license = new License({ ...validLicenseData, expiresAt: pastDate });

            await expect(license.save()).rejects.toThrow('Expiration date must be after creation date');
        });

        test('should require vendorId and productId', async () => {
            const noVendor = new License({ ...validLicenseData, vendorId: undefined });
            await expect(noVendor.save()).rejects.toThrow('Vendor ID is required');

            const noProduct = new License({ ...validLicenseData, productId: undefined });
            await expect(noProduct.save()).rejects.toThrow('Product ID is required');
        });
    });

    describe('Virtual Properties', () => {
        test('should calculate isExpired correctly', async () => {
            const futureDate = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
            const pastDate = new Date(Date.now() - 24 * 60 * 60 * 1000);

            const activeLicense = new License({
                licenseKey: 'ACTIVE-LICENSE-123',
                distributionLimit: 5,
                vendorId: 'vendor123',
                productId: 'product456',
                expiresAt: futureDate
            });

            const expiredLicense = new License({
                licenseKey: 'EXPIRED-LICENSE-123',
                distributionLimit: 5,
                vendorId: 'vendor123',
                productId: 'product456',
                expiresAt: pastDate
            });

            expect(activeLicense.isExpired).toBe(false);
            expect(expiredLicense.isExpired).toBe(true);
        });
    });

    describe('Instance Methods', () => {
        let license;

        beforeEach(async () => {
            license = new License({
                licenseKey: 'TEST-LICENSE-METHOD-123',
                distributionLimit: 3,
                vendorId: 'vendor123',
                productId: 'product456',
                expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)
            });
            await license.save();
        });

        test('canAcceptNewDistribution should work correctly', async () => {
            // Create a fresh license for this test
            const testLicense = new License({
                licenseKey: 'CAN-ACCEPT-TEST-LICENSE-123',
                distributionLimit: 3,
                vendorId: 'vendor123',
                productId: 'product456',
                expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)
            });
            await testLicense.save();

            expect(testLicense.canAcceptNewDistribution()).toBe(true);

            testLicense.currentDistributions = 3;
            expect(testLicense.canAcceptNewDistribution()).toBe(false);

            testLicense.currentDistributions = 2;
            testLicense.isActive = false;
            expect(testLicense.canAcceptNewDistribution()).toBe(false);
        });

        test('incrementDistribution should work correctly', async () => {
            // Create a fresh license for this test
            const testLicense = new License({
                licenseKey: 'INCREMENT-TEST-LICENSE-123',
                distributionLimit: 3,
                vendorId: 'vendor123',
                productId: 'product456',
                expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)
            });
            await testLicense.save();

            expect(testLicense.currentDistributions).toBe(0);
            expect(testLicense.isActive).toBe(true);
            expect(testLicense.isExpired).toBe(false);
            expect(testLicense.canAcceptNewDistribution()).toBe(true);

            await testLicense.incrementDistribution();
            expect(testLicense.currentDistributions).toBe(1);

            await testLicense.incrementDistribution();
            await testLicense.incrementDistribution();
            expect(testLicense.currentDistributions).toBe(3);

            try {
                await testLicense.incrementDistribution();
                expect.fail('Expected incrementDistribution to throw an error');
            } catch (error) {
                expect(error.message).toBe('Cannot increment distribution: limit reached or license inactive');
            }
        });
    });
});