ueberpruefen

__tests__/lib/utils/coneConverter.test.ts

@@ -0,0 +1,116 @@
+import {
+  getConeTemperature,
+  getConeData,
+  suggestConeFromTemperature,
+  isValidCone,
+  formatCone,
+  getBisqueCones,
+  getGlazeFiringCones,
+} from '../../../src/lib/utils/coneConverter';
+
+describe('Cone Converter', () => {
+  describe('getConeTemperature', () => {
+    it('returns temperature for cone 04 (bisque)', () => {
+      const temp = getConeTemperature('04');
+      expect(temp).not.toBeNull();
+      expect(temp?.value).toBe(1945);
+      expect(temp?.unit).toBe('F');
+    });
+
+    it('returns temperature for cone 6 (glaze firing)', () => {
+      const temp = getConeTemperature('6');
+      expect(temp).not.toBeNull();
+      expect(temp?.value).toBe(2232);
+      expect(temp?.unit).toBe('F');
+    });
+
+    it('returns temperature for cone 10', () => {
+      const temp = getConeTemperature('10');
+      expect(temp).not.toBeNull();
+      expect(temp?.value).toBe(2345);
+    });
+
+    it('handles cone 06 correctly', () => {
+      const temp = getConeTemperature('06');
+      expect(temp).not.toBeNull();
+      expect(temp?.value).toBe(1828);
+    });
+
+    it('returns null for invalid cone', () => {
+      const temp = getConeTemperature('999');
+      expect(temp).toBeNull();
+    });
+  });
+
+  describe('getConeData', () => {
+    it('returns full cone data', () => {
+      const data = getConeData('6');
+      expect(data).not.toBeNull();
+      expect(data?.cone).toBe('6');
+      expect(data?.fahrenheit).toBe(2232);
+      expect(data?.celsius).toBe(1222);
+      expect(data?.description).toContain('Stoneware');
+    });
+  });
+
+  describe('suggestConeFromTemperature', () => {
+    it('suggests cone 6 for 2232°F', () => {
+      const temp = { value: 2232, unit: 'F' as const };
+      const suggested = suggestConeFromTemperature(temp);
+      expect(suggested).not.toBeNull();
+      expect(suggested?.cone).toBe('6');
+    });
+
+    it('suggests cone 04 for 1945°F', () => {
+      const temp = { value: 1945, unit: 'F' as const };
+      const suggested = suggestConeFromTemperature(temp);
+      expect(suggested).not.toBeNull();
+      expect(suggested?.cone).toBe('04');
+    });
+
+    it('returns null for temperatures far from any cone', () => {
+      const temp = { value: 500, unit: 'F' as const };
+      const suggested = suggestConeFromTemperature(temp);
+      expect(suggested).toBeNull();
+    });
+  });
+
+  describe('isValidCone', () => {
+    it('validates common cones', () => {
+      expect(isValidCone('04')).toBe(true);
+      expect(isValidCone('06')).toBe(true);
+      expect(isValidCone('6')).toBe(true);
+      expect(isValidCone('10')).toBe(true);
+    });
+
+    it('rejects invalid cones', () => {
+      expect(isValidCone('99')).toBe(false);
+      expect(isValidCone('abc')).toBe(false);
+    });
+  });
+
+  describe('formatCone', () => {
+    it('formats cone number', () => {
+      expect(formatCone('04')).toBe('Cone 04');
+      expect(formatCone('6')).toBe('Cone 6');
+    });
+  });
+
+  describe('getBisqueCones', () => {
+    it('returns common bisque cones', () => {
+      const cones = getBisqueCones();
+      expect(cones).toContain('04');
+      expect(cones).toContain('03');
+      expect(cones.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getGlazeFiringCones', () => {
+    it('returns common glaze firing cones', () => {
+      const cones = getGlazeFiringCones();
+      expect(cones).toContain('6');
+      expect(cones).toContain('10');
+      expect(cones.length).toBeGreaterThan(0);
+    });
+  });
+});

__tests__/lib/utils/conversions.test.ts

@@ -0,0 +1,67 @@
+import {
+  fahrenheitToCelsius,
+  celsiusToFahrenheit,
+  convertTemperature,
+  formatTemperature,
+} from '../../../src/lib/utils/conversions';
+
+describe('Temperature Conversions', () => {
+  describe('fahrenheitToCelsius', () => {
+    it('converts 32°F to 0°C', () => {
+      expect(fahrenheitToCelsius(32)).toBe(0);
+    });
+
+    it('converts 212°F to 100°C', () => {
+      expect(fahrenheitToCelsius(212)).toBe(100);
+    });
+
+    it('converts 2232°F (cone 6) to approximately 1222°C', () => {
+      const result = fahrenheitToCelsius(2232);
+      expect(Math.round(result)).toBe(1222);
+    });
+  });
+
+  describe('celsiusToFahrenheit', () => {
+    it('converts 0°C to 32°F', () => {
+      expect(celsiusToFahrenheit(0)).toBe(32);
+    });
+
+    it('converts 100°C to 212°F', () => {
+      expect(celsiusToFahrenheit(100)).toBe(212);
+    });
+  });
+
+  describe('convertTemperature', () => {
+    it('returns same temperature if units match', () => {
+      const temp = { value: 100, unit: 'F' as const };
+      const result = convertTemperature(temp, 'F');
+      expect(result).toEqual(temp);
+    });
+
+    it('converts from F to C', () => {
+      const temp = { value: 2232, unit: 'F' as const };
+      const result = convertTemperature(temp, 'C');
+      expect(result.value).toBe(1222);
+      expect(result.unit).toBe('C');
+    });
+
+    it('converts from C to F', () => {
+      const temp = { value: 1222, unit: 'C' as const };
+      const result = convertTemperature(temp, 'F');
+      expect(result.value).toBe(2232);
+      expect(result.unit).toBe('F');
+    });
+  });
+
+  describe('formatTemperature', () => {
+    it('formats Fahrenheit temperature', () => {
+      const temp = { value: 2232, unit: 'F' as const };
+      expect(formatTemperature(temp)).toBe('2232°F');
+    });
+
+    it('formats Celsius temperature', () => {
+      const temp = { value: 1222, unit: 'C' as const };
+      expect(formatTemperature(temp)).toBe('1222°C');
+    });
+  });
+});

__tests__/lib/utils/datetime.test.ts

@@ -0,0 +1,52 @@
+import {
+  formatDuration,
+  parseDuration,
+} from '../../../src/lib/utils/datetime';
+
+describe('DateTime Utils', () => {
+  describe('formatDuration', () => {
+    it('formats minutes to h:mm', () => {
+      expect(formatDuration(60)).toBe('1:00');
+      expect(formatDuration(90)).toBe('1:30');
+      expect(formatDuration(125)).toBe('2:05');
+      expect(formatDuration(600)).toBe('10:00');
+    });
+
+    it('handles zero minutes', () => {
+      expect(formatDuration(0)).toBe('0:00');
+    });
+
+    it('handles less than 60 minutes', () => {
+      expect(formatDuration(45)).toBe('0:45');
+      expect(formatDuration(5)).toBe('0:05');
+    });
+  });
+
+  describe('parseDuration', () => {
+    it('parses h:mm to minutes', () => {
+      expect(parseDuration('1:00')).toBe(60);
+      expect(parseDuration('1:30')).toBe(90);
+      expect(parseDuration('2:05')).toBe(125);
+      expect(parseDuration('10:00')).toBe(600);
+    });
+
+    it('returns null for invalid format', () => {
+      expect(parseDuration('1:5')).toBeNull(); // missing leading zero
+      expect(parseDuration('abc')).toBeNull();
+      expect(parseDuration('1:60')).toBeNull(); // invalid minutes
+    });
+
+    it('handles zero duration', () => {
+      expect(parseDuration('0:00')).toBe(0);
+    });
+  });
+
+  describe('roundtrip conversion', () => {
+    it('format and parse roundtrip correctly', () => {
+      const minutes = 125;
+      const formatted = formatDuration(minutes);
+      const parsed = parseDuration(formatted);
+      expect(parsed).toBe(minutes);
+    });
+  });
+});