kempo-testing-framework 1.2.4 → 1.3.3

package/tests/counter.browser-test.js

@@ -1,141 +1,141 @@
-import './Counter.js';
-
-const wait = ms => new Promise(r=>setTimeout(r,ms));
-
-export const beforeAll = (log) => {
-  log('Setting up browser test environment for Counter component');
-}
-
-export const beforeEach = (log) => {
-  log('Setting up test fixture - creating counter element');
-  const $counter = document.createElement('my-counter');
-  $counter.id = 'test-counter';
-  document.body.appendChild($counter);
-}
-
-export const afterEach = (log) => {
-  log('Cleaning up - removing counter element');
-  const $counter = document.getElementById('test-counter');
-  if ($counter) {
-    $counter.remove();
-  }
-}
-
-export const afterAll = (log) => {
-  log('Cleaning up browser test environment');
-}
-
-export default {
-  'Counter component should be defined': ({pass, fail, log}) => {
-    log('Checking if my-counter element is defined');
-    if (window.customElements.get('my-counter')) {
-      pass('Counter component is properly registered');
-    } else {
-      fail('Counter component is not registered as a custom element');
-    }
-  },
-  
-  'Counter should render with initial count of 0': ({pass, fail, log}) => {
-    const $counter = document.getElementById('test-counter');
-    log('Checking initial counter value');
-    
-    if (!$counter) {
-      fail('Counter element not found');
-      return;
-    }
-    
-    // Check shadow DOM content
-    const countDisplay = $counter.shadowRoot.querySelector('div');
-    if (countDisplay && countDisplay.textContent.includes('Count: 0')) {
-      pass('Counter initializes with count of 0');
-    } else {
-      fail(`Counter does not show the expected initial value. Found: ${countDisplay?.textContent}`);
-    }
-  },
-  
-  'Counter should increment when clicked': async ({pass, fail, log}) => {
-    const counter = document.getElementById('test-counter');
-    log('Testing click increment functionality');
-    
-    if (!counter) {
-      fail('Counter element not found');
-      return;
-    }
-    
-    const button = counter.shadowRoot.querySelector('button');
-    
-    // Initial state check
-    let countDisplay = counter.shadowRoot.querySelector('div');
-    const initialText = countDisplay.textContent;
-    log(`Initial state: ${initialText}`);
-    
-    // Trigger click event
-    button.click();
-    
-    // Check updated state
-    countDisplay = counter.shadowRoot.querySelector('div');
-    const updatedText = countDisplay.textContent;
-    log(`After click: ${updatedText}`);
-    
-    if (updatedText.includes('Count: 1')) {
-      pass('Counter successfully incremented to 1 after click');
-    } else {
-      fail(`Counter did not increment properly. Expected 'Count: 1' but found '${updatedText}'`);
-    }
-  },
-  
-  'Counter should increment multiple times': async ({pass, fail, log}) => {
-    const counter = document.getElementById('test-counter');
-    log('Testing multiple increments');
-    
-    if (!counter) {
-      fail('Counter element not found');
-      return;
-    }
-    
-    const button = counter.shadowRoot.querySelector('button');
-    
-    // Simply click the button multiple times
-    for (let i = 0; i < 3; i++) {
-      button.click();
-      await wait(100);
-      log(`After click ${i+1}, counter shows: ${counter.shadowRoot.querySelector('div').textContent}`);
-    }
-    
-    const countDisplay = counter.shadowRoot.querySelector('div');
-    const countText = countDisplay.textContent;
-    
-    if (countText.includes('Count: 3')) {
-      pass('Counter successfully incremented multiple times to 3');
-    } else {
-      fail(`Counter did not increment correctly after multiple clicks. Expected 'Count: 3' but found '${countText}'`);
-    }
-  },
-  
-  'Counter should maintain internal state': ({pass, fail, log}) => {
-    const counter = document.getElementById('test-counter');
-    log('Testing internal state management');
-    
-    if (!counter) {
-      fail('Counter element not found');
-      return;
-    }
-    
-    // Check initial internal state
-    if (counter.count === 0) {
-      // Manually update the internal state
-      counter.count = 42;
-      counter.render();
-      
-      // Verify the rendered output matches the internal state
-      const countDisplay = counter.shadowRoot.querySelector('div');
-      if (countDisplay.textContent.includes('Count: 42')) {
-        pass('Counter maintains and displays internal state correctly');
-      } else {
-        fail(`Counter does not display the expected state. Expected 'Count: 42' but found '${countDisplay.textContent}'`);
-      }
-    } else {
-      fail(`Initial counter state is not 0, found: ${counter.count}`);
-    }
-  }
+import './Counter.js';
+
+const wait = ms => new Promise(r=>setTimeout(r,ms));
+
+export const beforeAll = (log) => {
+  log('Setting up browser test environment for Counter component');
+}
+
+export const beforeEach = (log) => {
+  log('Setting up test fixture - creating counter element');
+  const $counter = document.createElement('my-counter');
+  $counter.id = 'test-counter';
+  document.body.appendChild($counter);
+}
+
+export const afterEach = (log) => {
+  log('Cleaning up - removing counter element');
+  const $counter = document.getElementById('test-counter');
+  if ($counter) {
+    $counter.remove();
+  }
+}
+
+export const afterAll = (log) => {
+  log('Cleaning up browser test environment');
+}
+
+export default {
+  'Counter component should be defined': ({pass, fail, log}) => {
+    log('Checking if my-counter element is defined');
+    if (window.customElements.get('my-counter')) {
+      pass('Counter component is properly registered');
+    } else {
+      fail('Counter component is not registered as a custom element');
+    }
+  },
+  
+  'Counter should render with initial count of 0': ({pass, fail, log}) => {
+    const $counter = document.getElementById('test-counter');
+    log('Checking initial counter value');
+    
+    if (!$counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    // Check shadow DOM content
+    const countDisplay = $counter.shadowRoot.querySelector('div');
+    if (countDisplay && countDisplay.textContent.includes('Count: 0')) {
+      pass('Counter initializes with count of 0');
+    } else {
+      fail(`Counter does not show the expected initial value. Found: ${countDisplay?.textContent}`);
+    }
+  },
+  
+  'Counter should increment when clicked': async ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing click increment functionality');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    const button = counter.shadowRoot.querySelector('button');
+    
+    // Initial state check
+    let countDisplay = counter.shadowRoot.querySelector('div');
+    const initialText = countDisplay.textContent;
+    log(`Initial state: ${initialText}`);
+    
+    // Trigger click event
+    button.click();
+    
+    // Check updated state
+    countDisplay = counter.shadowRoot.querySelector('div');
+    const updatedText = countDisplay.textContent;
+    log(`After click: ${updatedText}`);
+    
+    if (updatedText.includes('Count: 1')) {
+      pass('Counter successfully incremented to 1 after click');
+    } else {
+      fail(`Counter did not increment properly. Expected 'Count: 1' but found '${updatedText}'`);
+    }
+  },
+  
+  'Counter should increment multiple times': async ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing multiple increments');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    const button = counter.shadowRoot.querySelector('button');
+    
+    // Simply click the button multiple times
+    for (let i = 0; i < 3; i++) {
+      button.click();
+      await wait(100);
+      log(`After click ${i+1}, counter shows: ${counter.shadowRoot.querySelector('div').textContent}`);
+    }
+    
+    const countDisplay = counter.shadowRoot.querySelector('div');
+    const countText = countDisplay.textContent;
+    
+    if (countText.includes('Count: 3')) {
+      pass('Counter successfully incremented multiple times to 3');
+    } else {
+      fail(`Counter did not increment correctly after multiple clicks. Expected 'Count: 3' but found '${countText}'`);
+    }
+  },
+  
+  'Counter should maintain internal state': ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing internal state management');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    // Check initial internal state
+    if (counter.count === 0) {
+      // Manually update the internal state
+      counter.count = 42;
+      counter.render();
+      
+      // Verify the rendered output matches the internal state
+      const countDisplay = counter.shadowRoot.querySelector('div');
+      if (countDisplay.textContent.includes('Count: 42')) {
+        pass('Counter maintains and displays internal state correctly');
+      } else {
+        fail(`Counter does not display the expected state. Expected 'Count: 42' but found '${countDisplay.textContent}'`);
+      }
+    } else {
+      fail(`Initial counter state is not 0, found: ${counter.count}`);
+    }
+  }
 };

package/tests/example.node-test.js

@@ -1,103 +1,103 @@
-// Example Node test file for Kempo Testing Framework
-// This demonstrates the basic structure and features
-
-/* Export the optional lifecycle callbacks */
-export const beforeAll = async (log) => {
-  log('Setting up Node test environment...');
-  // Setup that runs once before all tests
-}
-
-export const beforeEach = async (log) => {
-  log('Setting up for each test');
-  // Setup that runs before each individual test
-}
-
-export const afterEach = async (log) => {
-  log('Cleaning up after each test');
-  // Cleanup that runs after each individual test
-}
-
-export const afterAll = async (log) => {
-  log('Cleaning up Node test environment...');
-  // Cleanup that runs once after all tests
-}
-
-/* Export the Tests */
-export default {
-  'should handle basic string operations': async ({pass, fail, log}) => {
-    const input = 'hello world';
-    const expected = 'HELLO WORLD';
-    const result = input.toUpperCase();
-    
-    log(`Testing string conversion: "${input}" -> "${result}"`);
-    
-    if (result === expected) {
-      log('✓ String conversion works correctly');
-      pass('String uppercase conversion test passed');
-    } else {
-      fail(`Expected "${expected}", got "${result}"`);
-    }
-  },
-
-  'should validate array operations': async ({pass, fail, log}) => {
-    const numbers = [1, 2, 3, 4, 5];
-    const doubled = numbers.map(n => n * 2);
-    const expected = [2, 4, 6, 8, 10];
-    
-    log(`Testing array mapping: [${numbers}] -> [${doubled}]`);
-    
-    if (JSON.stringify(doubled) === JSON.stringify(expected)) {
-      log('✓ Array mapping works correctly');
-      pass('Array mapping test passed');
-    } else {
-      fail(`Expected [${expected}], got [${doubled}]`);
-    }
-  },
-
-  'should handle async operations': async ({pass, fail, log}) => {
-    log('Testing async operation...');
-    
-    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-    const start = Date.now();
-    
-    await delay(100);
-    
-    const elapsed = Date.now() - start;
-    log(`Async delay completed in ${elapsed}ms`);
-    
-    if (elapsed >= 100 && elapsed < 200) {
-      log('✓ Async operation timing is correct');
-      pass('Async operation test passed');
-    } else {
-      fail(`Expected delay of ~100ms, got ${elapsed}ms`);
-    }
-  },
-
-  'should handle error conditions': async ({pass, fail, log}) => {
-    log('Testing error handling...');
-    
-    try {
-      JSON.parse('invalid json');
-      fail('Should have thrown an error for invalid JSON');
-    } catch (error) {
-      log(`✓ Caught expected error: ${error.message}`);
-      pass('Error handling test passed');
-    }
-  },
-
-  'should work with Node.js specific features': async ({pass, fail, log}) => {
-    // Test Node.js specific functionality
-    const process_exists = typeof process !== 'undefined';
-    const has_global = typeof global !== 'undefined';
-    
-    log(`Process object exists: ${process_exists}`);
-    log(`Global object available: ${has_global}`);
-    
-    if (process_exists && has_global) {
-      log('✓ Node.js environment detected correctly');
-      pass('Node.js environment test passed');
-    } else {
-      fail('Node.js environment features not available');
-    }
-  }
-};
+// Example Node test file for Kempo Testing Framework
+// This demonstrates the basic structure and features
+
+/* Export the optional lifecycle callbacks */
+export const beforeAll = async (log) => {
+  log('Setting up Node test environment...');
+  // Setup that runs once before all tests
+}
+
+export const beforeEach = async (log) => {
+  log('Setting up for each test');
+  // Setup that runs before each individual test
+}
+
+export const afterEach = async (log) => {
+  log('Cleaning up after each test');
+  // Cleanup that runs after each individual test
+}
+
+export const afterAll = async (log) => {
+  log('Cleaning up Node test environment...');
+  // Cleanup that runs once after all tests
+}
+
+/* Export the Tests */
+export default {
+  'should handle basic string operations': async ({pass, fail, log}) => {
+    const input = 'hello world';
+    const expected = 'HELLO WORLD';
+    const result = input.toUpperCase();
+    
+    log(`Testing string conversion: "${input}" -> "${result}"`);
+    
+    if (result === expected) {
+      log('✓ String conversion works correctly');
+      pass('String uppercase conversion test passed');
+    } else {
+      fail(`Expected "${expected}", got "${result}"`);
+    }
+  },
+
+  'should validate array operations': async ({pass, fail, log}) => {
+    const numbers = [1, 2, 3, 4, 5];
+    const doubled = numbers.map(n => n * 2);
+    const expected = [2, 4, 6, 8, 10];
+    
+    log(`Testing array mapping: [${numbers}] -> [${doubled}]`);
+    
+    if (JSON.stringify(doubled) === JSON.stringify(expected)) {
+      log('✓ Array mapping works correctly');
+      pass('Array mapping test passed');
+    } else {
+      fail(`Expected [${expected}], got [${doubled}]`);
+    }
+  },
+
+  'should handle async operations': async ({pass, fail, log}) => {
+    log('Testing async operation...');
+    
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    const start = Date.now();
+    
+    await delay(100);
+    
+    const elapsed = Date.now() - start;
+    log(`Async delay completed in ${elapsed}ms`);
+    
+    if (elapsed >= 100 && elapsed < 200) {
+      log('✓ Async operation timing is correct');
+      pass('Async operation test passed');
+    } else {
+      fail(`Expected delay of ~100ms, got ${elapsed}ms`);
+    }
+  },
+
+  'should handle error conditions': async ({pass, fail, log}) => {
+    log('Testing error handling...');
+    
+    try {
+      JSON.parse('invalid json');
+      fail('Should have thrown an error for invalid JSON');
+    } catch (error) {
+      log(`✓ Caught expected error: ${error.message}`);
+      pass('Error handling test passed');
+    }
+  },
+
+  'should work with Node.js specific features': async ({pass, fail, log}) => {
+    // Test Node.js specific functionality
+    const process_exists = typeof process !== 'undefined';
+    const has_global = typeof global !== 'undefined';
+    
+    log(`Process object exists: ${process_exists}`);
+    log(`Global object available: ${has_global}`);
+    
+    if (process_exists && has_global) {
+      log('✓ Node.js environment detected correctly');
+      pass('Node.js environment test passed');
+    } else {
+      fail('Node.js environment features not available');
+    }
+  }
+};

package/tests/fibonacci.js

@@ -1,92 +1,92 @@
-/**
- * Fibonacci sequence utility functions
- * Works in both Node.js and browser environments
- */
-
-/**
- * Generate the nth Fibonacci number (0-indexed)
- * @param {number} n - The position in the sequence (0-indexed)
- * @returns {number} The Fibonacci number at position n
- * @throws {Error} If n is negative or not a number
- */
-const fibonacci = (n) => {
-  if(typeof n !== 'number' || !Number.isInteger(n)) {
-    throw new Error('Input must be a non-negative integer');
-  }
-  
-  if(n < 0) {
-    throw new Error('Input must be a non-negative integer');
-  }
-  
-  if(n === 0) return 0;
-  if(n === 1) return 1;
-  
-  let a = 0;
-  let b = 1;
-  
-  for(let i = 2; i <= n; i++) {
-    const temp = a + b;
-    a = b;
-    b = temp;
-  }
-  
-  return b;
-};
-
-/**
- * Generate a Fibonacci sequence up to n terms
- * @param {number} count - Number of terms to generate
- * @returns {number[]} Array containing the Fibonacci sequence
- * @throws {Error} If count is negative or not a number
- */
-const fibonacciSequence = (count) => {
-  if(typeof count !== 'number' || !Number.isInteger(count)) {
-    throw new Error('Count must be a non-negative integer');
-  }
-  
-  if(count < 0) {
-    throw new Error('Count must be a non-negative integer');
-  }
-  
-  if(count === 0) return [];
-  if(count === 1) return [0];
-  if(count === 2) return [0, 1];
-  
-  const sequence = [0, 1];
-  
-  for(let i = 2; i < count; i++) {
-    sequence.push(sequence[i - 1] + sequence[i - 2]);
-  }
-  
-  return sequence;
-};
-
-/**
- * Check if a number is a Fibonacci number
- * @param {number} num - The number to check
- * @returns {boolean} True if the number is in the Fibonacci sequence
- */
-const isFibonacci = (num) => {
-  if(typeof num !== 'number' || !Number.isInteger(num) || num < 0) {
-    return false;
-  }
-  
-  if(num === 0 || num === 1) return true;
-  
-  let a = 0;
-  let b = 1;
-  
-  while (b < num) {
-    const temp = a + b;
-    a = b;
-    b = temp;
-  }
-  
-  return b === num;
-};
-
-export default {
-  fibonacci,
-  fibonacciSequence,
-  isFibonacci
-};
+/**
+ * Fibonacci sequence utility functions
+ * Works in both Node.js and browser environments
+ */
+
+/**
+ * Generate the nth Fibonacci number (0-indexed)
+ * @param {number} n - The position in the sequence (0-indexed)
+ * @returns {number} The Fibonacci number at position n
+ * @throws {Error} If n is negative or not a number
+ */
+const fibonacci = (n) => {
+  if(typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  
+  if(n < 0) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  
+  if(n === 0) return 0;
+  if(n === 1) return 1;
+  
+  let a = 0;
+  let b = 1;
+  
+  for(let i = 2; i <= n; i++) {
+    const temp = a + b;
+    a = b;
+    b = temp;
+  }
+  
+  return b;
+};
+
+/**
+ * Generate a Fibonacci sequence up to n terms
+ * @param {number} count - Number of terms to generate
+ * @returns {number[]} Array containing the Fibonacci sequence
+ * @throws {Error} If count is negative or not a number
+ */
+const fibonacciSequence = (count) => {
+  if(typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new Error('Count must be a non-negative integer');
+  }
+  
+  if(count < 0) {
+    throw new Error('Count must be a non-negative integer');
+  }
+  
+  if(count === 0) return [];
+  if(count === 1) return [0];
+  if(count === 2) return [0, 1];
+  
+  const sequence = [0, 1];
+  
+  for(let i = 2; i < count; i++) {
+    sequence.push(sequence[i - 1] + sequence[i - 2]);
+  }
+  
+  return sequence;
+};
+
+/**
+ * Check if a number is a Fibonacci number
+ * @param {number} num - The number to check
+ * @returns {boolean} True if the number is in the Fibonacci sequence
+ */
+const isFibonacci = (num) => {
+  if(typeof num !== 'number' || !Number.isInteger(num) || num < 0) {
+    return false;
+  }
+  
+  if(num === 0 || num === 1) return true;
+  
+  let a = 0;
+  let b = 1;
+  
+  while (b < num) {
+    const temp = a + b;
+    a = b;
+    b = temp;
+  }
+  
+  return b === num;
+};
+
+export default {
+  fibonacci,
+  fibonacciSequence,
+  isFibonacci
+};