microui-wc 0.1.0

package/tests/core/feature-registry.test.js

@@ -0,0 +1,198 @@
+/**
+ * @fileoverview Tests for Feature Registry (Enterprise Features)
+ * Tests createFeature, getFeatures, getFeature, getFeatureComponents, destroyFeature
+ */
+
+import { describe, test, expect, beforeEach, beforeAll } from 'bun:test';
+
+let createFeature, getFeatures, getFeature, getFeatureComponents;
+let getFeatureRoutes, getFeatureByRoute, getFeatureByComponent;
+let destroyFeature, getFeatureSummary, clearFeatures, FeatureRegistry;
+
+describe('Feature Registry', () => {
+
+    beforeAll(async () => {
+        const module = await import('../../src/core/feature-registry.js');
+        createFeature = module.createFeature;
+        getFeatures = module.getFeatures;
+        getFeature = module.getFeature;
+        getFeatureComponents = module.getFeatureComponents;
+        getFeatureRoutes = module.getFeatureRoutes;
+        getFeatureByRoute = module.getFeatureByRoute;
+        getFeatureByComponent = module.getFeatureByComponent;
+        destroyFeature = module.destroyFeature;
+        getFeatureSummary = module.getFeatureSummary;
+        clearFeatures = module.clearFeatures;
+        FeatureRegistry = module.FeatureRegistry;
+    });
+
+    beforeEach(() => { clearFeatures(); });
+
+    // ========================================
+    // createFeature
+    // ========================================
+
+    test('createFeature creates feature with name', () => {
+        const f = createFeature('user', { routes: ['/user'] });
+        expect(f.name).toBe('user');
+    });
+
+    test('createFeature returns existing for same name', () => {
+        const f1 = createFeature('dup', {});
+        const f2 = createFeature('dup', { routes: ['/x'] });
+        expect(f1).toBe(f2);
+    });
+
+    test('createFeature with init calls init', () => {
+        let called = false;
+        createFeature('init-test', { init: () => { called = true; } });
+        expect(called).toBe(true);
+    });
+
+    test('createFeature with init sets initialized', () => {
+        const f = createFeature('init-flag', { init: () => { } });
+        expect(f.initialized).toBe(true);
+    });
+
+    test('createFeature sets registeredAt', () => {
+        const f = createFeature('time', {});
+        expect(typeof f.registeredAt).toBe('number');
+    });
+
+    test('createFeature handles init error', () => {
+        const f = createFeature('err', { init: () => { throw new Error('fail'); } });
+        expect(f.initialized).toBe(false);
+    });
+
+    // ========================================
+    // getFeatures / getFeature
+    // ========================================
+
+    test('getFeatures returns all features', () => {
+        createFeature('a', {});
+        createFeature('b', {});
+        const all = getFeatures();
+        expect(all.a).toBeDefined();
+        expect(all.b).toBeDefined();
+    });
+
+    test('getFeature returns feature by name', () => {
+        createFeature('single', { meta: { v: 1 } });
+        const f = getFeature('single');
+        expect(f.config.meta.v).toBe(1);
+    });
+
+    test('getFeature returns undefined for unknown', () => {
+        expect(getFeature('unknown')).toBeUndefined();
+    });
+
+    // ========================================
+    // getFeatureComponents / getFeatureRoutes
+    // ========================================
+
+    test('getFeatureComponents returns components', () => {
+        createFeature('comp', { components: ['mu-card', 'mu-form'] });
+        expect(getFeatureComponents('comp')).toEqual(['mu-card', 'mu-form']);
+    });
+
+    test('getFeatureRoutes returns routes', () => {
+        createFeature('route', { routes: ['/a', '/b'] });
+        expect(getFeatureRoutes('route')).toEqual(['/a', '/b']);
+    });
+
+    test('getFeatureComponents returns empty for unknown', () => {
+        expect(getFeatureComponents('nope')).toEqual([]);
+    });
+
+    test('getFeatureRoutes returns empty for unknown', () => {
+        expect(getFeatureRoutes('nope')).toEqual([]);
+    });
+
+    // ========================================
+    // getFeatureByRoute / getFeatureByComponent
+    // ========================================
+
+    test('getFeatureByRoute finds by route prefix', () => {
+        createFeature('admin', { routes: ['/admin'] });
+        const f = getFeatureByRoute('/admin/users');
+        expect(f.name).toBe('admin');
+    });
+
+    test('getFeatureByRoute returns null if no match', () => {
+        expect(getFeatureByRoute('/nonexistent')).toBeNull();
+    });
+
+    test('getFeatureByComponent finds by component tag', () => {
+        createFeature('widgets', { components: ['mu-widget'] });
+        const f = getFeatureByComponent('mu-widget');
+        expect(f.name).toBe('widgets');
+    });
+
+    test('getFeatureByComponent returns null if no match', () => {
+        expect(getFeatureByComponent('mu-unknown')).toBeNull();
+    });
+
+    // ========================================
+    // destroyFeature
+    // ========================================
+
+    test('destroyFeature removes feature', () => {
+        createFeature('destroy-test', {});
+        destroyFeature('destroy-test');
+        expect(getFeature('destroy-test')).toBeUndefined();
+    });
+
+    test('destroyFeature calls destroy callback', () => {
+        let called = false;
+        createFeature('destroy-cb', { destroy: () => { called = true; } });
+        destroyFeature('destroy-cb');
+        expect(called).toBe(true);
+    });
+
+    test('destroyFeature handles non-existent', () => {
+        destroyFeature('nope');
+        expect(true).toBe(true);
+    });
+
+    test('destroyFeature handles destroy error', () => {
+        createFeature('destroy-err', { destroy: () => { throw new Error('fail'); } });
+        destroyFeature('destroy-err');
+        expect(getFeature('destroy-err')).toBeUndefined();
+    });
+
+    // ========================================
+    // getFeatureSummary
+    // ========================================
+
+    test('getFeatureSummary returns summary object', () => {
+        createFeature('s1', { routes: ['/x'], components: ['a'], store: {} });
+        const summary = getFeatureSummary();
+        expect(summary.totalFeatures).toBe(1);
+        expect(summary.totalRoutes).toBe(1);
+        expect(summary.totalComponents).toBe(1);
+        expect(summary.features[0].hasStore).toBe(true);
+    });
+
+    // ========================================
+    // clearFeatures
+    // ========================================
+
+    test('clearFeatures removes all features', () => {
+        createFeature('a', {});
+        createFeature('b', {});
+        clearFeatures();
+        expect(Object.keys(getFeatures()).length).toBe(0);
+    });
+
+    // ========================================
+    // FeatureRegistry export
+    // ========================================
+
+    test('FeatureRegistry has all methods', () => {
+        expect(FeatureRegistry.createFeature).toBe(createFeature);
+        expect(FeatureRegistry.getFeatures).toBe(getFeatures);
+        expect(FeatureRegistry.clearFeatures).toBe(clearFeatures);
+        expect(FeatureRegistry.destroyFeature).toBe(destroyFeature);
+        expect(FeatureRegistry.getFeatureSummary).toBe(getFeatureSummary);
+    });
+});

package/tests/core/form-state.test.js

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview Unit Tests for form-state.js Module
+ * Target: 84% → 95% coverage
+ */
+
+import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
+import { parseHTML } from 'linkedom';
+
+let createFormState;
+
+describe('form-state Module Unit Tests', () => {
+
+    beforeAll(async () => {
+        const dom = parseHTML('<!DOCTYPE html><html><body></body></html>');
+        globalThis.document = dom.document;
+        globalThis.window = dom.window;
+        globalThis.HTMLElement = dom.HTMLElement;
+        globalThis.MutationObserver = class { observe() { } disconnect() { } };
+
+        const module = await import('../../src/core/form-state.js');
+        createFormState = module.createFormState;
+    });
+
+    beforeEach(() => {
+        globalThis.document.body.innerHTML = '';
+    });
+
+    // CREATE FORM STATE
+    test('createFormState should be a function', () => {
+        expect(typeof createFormState).toBe('function');
+    });
+
+    test('createFormState should return object', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state).toBe('object');
+    });
+
+    test('createFormState should have fields property', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(state.fields).toBeDefined();
+    });
+
+    test('createFormState should have isValid property', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.isValid).toBe('boolean');
+    });
+
+    test('createFormState should have isDirty property', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.isDirty).toBe('boolean');
+    });
+
+    test('createFormState should have isSubmitting property', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.isSubmitting).toBe('boolean');
+    });
+
+    test('createFormState should have getValues method', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.getValues).toBe('function');
+    });
+
+    test('createFormState should have getErrors method', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.getErrors).toBe('function');
+    });
+
+    test('createFormState should have reset method', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.reset).toBe('function');
+    });
+
+    test('createFormState should have validate method', () => {
+        const form = globalThis.document.createElement('form');
+        const state = createFormState(form, {});
+        expect(typeof state.validate).toBe('function');
+    });
+
+    // WITH SCHEMA
+    test('should create field from schema', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: { required: true } });
+        expect(state.fields.email).toBeDefined();
+    });
+
+    test('field should have value property', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="test@example.com">';
+        const state = createFormState(form, { email: {} });
+        expect(state.fields.email.value).toBe('test@example.com');
+    });
+
+    test('field should have error property', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: { required: true } });
+        expect(state.fields.email.error).toBeDefined();
+    });
+
+    test('field should have touched property', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: {} });
+        expect(state.fields.email.touched).toBe(false);
+    });
+
+    test('field should have dirty property', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: {} });
+        expect(state.fields.email.dirty).toBe(false);
+    });
+
+    // VALIDATION
+    test('isValid should be true for valid form', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="test@example.com">';
+        const state = createFormState(form, { email: { type: 'email' } });
+        expect(state.isValid).toBe(true);
+    });
+
+    test('isValid should be false for invalid form', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: { required: true } });
+        expect(state.isValid).toBe(false);
+    });
+
+    // METHODS
+    test('getValues should return all values', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="test@example.com">';
+        const state = createFormState(form, { email: {} });
+        expect(state.getValues().email).toBe('test@example.com');
+    });
+
+    test('getErrors should return all errors', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="">';
+        const state = createFormState(form, { email: { required: true } });
+        expect(state.getErrors().email).toBeDefined();
+    });
+
+    test('reset should clear values', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="test@example.com">';
+        const state = createFormState(form, { email: {} });
+        state.reset();
+        expect(state.isDirty).toBe(false);
+    });
+
+    test('validate should return boolean', () => {
+        const form = globalThis.document.createElement('form');
+        form.innerHTML = '<input name="email" value="test@example.com">';
+        const state = createFormState(form, { email: {} });
+        expect(typeof state.validate()).toBe('boolean');
+    });
+});

package/tests/core/http.test.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Unit Tests for http.js Module
+ * Target: 21% → 80% coverage
+ */
+
+import { describe, test, expect, beforeAll, beforeEach, mock } from 'bun:test';
+import { http, HttpError } from '../../src/core/http.js';
+
+describe('http Module Unit Tests', () => {
+
+    beforeEach(() => {
+        // Reset state
+        http.baseURL = '';
+        http.headers = { 'Content-Type': 'application/json' };
+    });
+
+    // HTTP OBJECT
+    test('http should exist', () => {
+        expect(http).toBeDefined();
+    });
+
+    test('http should have baseURL property', () => {
+        expect(http.baseURL).toBe('');
+    });
+
+    test('http should have headers property', () => {
+        expect(http.headers['Content-Type']).toBe('application/json');
+    });
+
+    // SET BASE URL
+    test('setBaseURL should set baseURL', () => {
+        http.setBaseURL('https://api.example.com');
+        expect(http.baseURL).toBe('https://api.example.com');
+    });
+
+    // SET HEADER
+    test('setHeader should add header', () => {
+        http.setHeader('Authorization', 'Bearer token123');
+        expect(http.headers['Authorization']).toBe('Bearer token123');
+    });
+
+    test('setHeader should overwrite existing header', () => {
+        http.setHeader('Content-Type', 'text/plain');
+        expect(http.headers['Content-Type']).toBe('text/plain');
+    });
+
+    // HTTP METHODS
+    test('get should be a function', () => {
+        expect(typeof http.get).toBe('function');
+    });
+
+    test('post should be a function', () => {
+        expect(typeof http.post).toBe('function');
+    });
+
+    test('put should be a function', () => {
+        expect(typeof http.put).toBe('function');
+    });
+
+    test('delete should be a function', () => {
+        expect(typeof http.delete).toBe('function');
+    });
+
+    test('request should be a function', () => {
+        expect(typeof http.request).toBe('function');
+    });
+
+    // HTTP ERROR CLASS
+    test('HttpError should be a class', () => {
+        expect(HttpError).toBeDefined();
+    });
+
+    test('HttpError should extend Error', () => {
+        const err = new HttpError(404, 'Not Found', 'Resource not found');
+        expect(err instanceof Error).toBe(true);
+    });
+
+    test('HttpError should have status property', () => {
+        const err = new HttpError(500, 'Internal Server Error', 'body');
+        expect(err.status).toBe(500);
+    });
+
+    test('HttpError should have statusText property', () => {
+        const err = new HttpError(403, 'Forbidden', 'body');
+        expect(err.statusText).toBe('Forbidden');
+    });
+
+    test('HttpError should have body property', () => {
+        const err = new HttpError(400, 'Bad Request', 'Invalid data');
+        expect(err.body).toBe('Invalid data');
+    });
+
+    test('HttpError message should be formatted', () => {
+        const err = new HttpError(401, 'Unauthorized', 'body');
+        expect(err.message).toBe('HTTP 401: Unauthorized');
+    });
+
+    test('HttpError should be throwable', () => {
+        expect(() => { throw new HttpError(500, 'Error', 'body'); }).toThrow();
+    });
+
+    // REQUEST METHOD SIGNATURES
+    test('get should accept url and options', () => {
+        // Just verify it doesn't throw on call signature
+        expect(() => http.get).not.toThrow();
+    });
+
+    test('post should accept url, body and options', () => {
+        expect(() => http.post).not.toThrow();
+    });
+
+    test('put should accept url, body and options', () => {
+        expect(() => http.put).not.toThrow();
+    });
+
+    test('delete should accept url and options', () => {
+        expect(() => http.delete).not.toThrow();
+    });
+});