+226

tests/automations.test.ts

reviewed

··· 157 157 expect(duplicateRule(state, 'unknown')).toBe(state); 158 158 }); 159 159 }); 160 160 + 161 161 + // ===================================================================== 162 162 + // Edge cases 163 163 + // ===================================================================== 164 164 + 165 165 + describe('addRule — edge cases', () => { 166 166 + it('generates unique IDs for multiple rules', () => { 167 167 + let state = createAutomationState(); 168 168 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 169 169 + state = addRule(state, 'R2', { type: 'cell_changed' }, []); 170 170 + expect(state.rules[0].id).not.toBe(state.rules[1].id); 171 171 + }); 172 172 + 173 173 + it('adds rule with multiple actions', () => { 174 174 + let state = createAutomationState(); 175 175 + state = addRule(state, 'Multi', { type: 'cell_changed' }, [ 176 176 + { type: 'set_color', color: '#ff0000' }, 177 177 + { type: 'set_cell', value: 'Done' }, 178 178 + { type: 'set_timestamp' }, 179 179 + ]); 180 180 + expect(state.rules[0].actions).toHaveLength(3); 181 181 + }); 182 182 + 183 183 + it('defaults maxExecutions to 0 (unlimited)', () => { 184 184 + let state = createAutomationState(); 185 185 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 186 186 + expect(state.rules[0].maxExecutions).toBe(0); 187 187 + }); 188 188 + 189 189 + it('respects explicit maxExecutions', () => { 190 190 + let state = createAutomationState(); 191 191 + state = addRule(state, 'R1', { type: 'cell_changed' }, [], 5); 192 192 + expect(state.rules[0].maxExecutions).toBe(5); 193 193 + }); 194 194 + 195 195 + it('starts with executionCount 0', () => { 196 196 + let state = createAutomationState(); 197 197 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 198 198 + expect(state.rules[0].executionCount).toBe(0); 199 199 + }); 200 200 + 201 201 + it('starts enabled', () => { 202 202 + let state = createAutomationState(); 203 203 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 204 204 + expect(state.rules[0].enabled).toBe(true); 205 205 + }); 206 206 + }); 207 207 + 208 208 + describe('removeRule — edge cases', () => { 209 209 + it('removing nonexistent ID returns same rules', () => { 210 210 + let state = createAutomationState(); 211 211 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 212 212 + const result = removeRule(state, 'nonexistent'); 213 213 + expect(result.rules).toHaveLength(1); 214 214 + }); 215 215 + 216 216 + it('removes from middle of list', () => { 217 217 + let state = createAutomationState(); 218 218 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 219 219 + state = addRule(state, 'R2', { type: 'cell_changed' }, []); 220 220 + state = addRule(state, 'R3', { type: 'cell_changed' }, []); 221 221 + const middleId = state.rules[1].id; 222 222 + state = removeRule(state, middleId); 223 223 + expect(state.rules).toHaveLength(2); 224 224 + expect(state.rules[0].name).toBe('R1'); 225 225 + expect(state.rules[1].name).toBe('R3'); 226 226 + }); 227 227 + }); 228 228 + 229 229 + describe('matchesTrigger — edge cases', () => { 230 230 + it('cell_changed with row filter', () => { 231 231 + expect(matchesTrigger( 232 232 + { type: 'cell_changed', row: 5 }, 233 233 + { column: 0, row: 5, oldValue: '', newValue: 'x' }, 234 234 + )).toBe(true); 235 235 + expect(matchesTrigger( 236 236 + { type: 'cell_changed', row: 5 }, 237 237 + { column: 0, row: 3, oldValue: '', newValue: 'x' }, 238 238 + )).toBe(false); 239 239 + }); 240 240 + 241 241 + it('cell_changed with both column and row filter', () => { 242 242 + expect(matchesTrigger( 243 243 + { type: 'cell_changed', column: 2, row: 3 }, 244 244 + { column: 2, row: 3, oldValue: '', newValue: 'x' }, 245 245 + )).toBe(true); 246 246 + expect(matchesTrigger( 247 247 + { type: 'cell_changed', column: 2, row: 3 }, 248 248 + { column: 2, row: 4, oldValue: '', newValue: 'x' }, 249 249 + )).toBe(false); 250 250 + }); 251 251 + 252 252 + it('row_added always matches', () => { 253 253 + expect(matchesTrigger( 254 254 + { type: 'row_added' }, 255 255 + { column: 0, row: 0, oldValue: '', newValue: '' }, 256 256 + )).toBe(true); 257 257 + }); 258 258 + 259 259 + it('row_deleted always matches', () => { 260 260 + expect(matchesTrigger( 261 261 + { type: 'row_deleted' }, 262 262 + { column: 0, row: 0, oldValue: '', newValue: '' }, 263 263 + )).toBe(true); 264 264 + }); 265 265 + 266 266 + it('value_greater_than with non-numeric value returns false', () => { 267 267 + expect(matchesTrigger( 268 268 + { type: 'value_greater_than', value: '10' }, 269 269 + { column: 0, row: 0, oldValue: '', newValue: 'abc' }, 270 270 + )).toBe(false); 271 271 + }); 272 272 + 273 273 + it('value_less_than with non-numeric value returns false', () => { 274 274 + expect(matchesTrigger( 275 275 + { type: 'value_less_than', value: '10' }, 276 276 + { column: 0, row: 0, oldValue: '', newValue: 'abc' }, 277 277 + )).toBe(false); 278 278 + }); 279 279 + 280 280 + it('value_contains is case-insensitive', () => { 281 281 + expect(matchesTrigger( 282 282 + { type: 'value_contains', value: 'HELLO' }, 283 283 + { column: 0, row: 0, oldValue: '', newValue: 'say hello world' }, 284 284 + )).toBe(true); 285 285 + }); 286 286 + 287 287 + it('value_is_empty matches null', () => { 288 288 + expect(matchesTrigger( 289 289 + { type: 'value_is_empty' }, 290 290 + { column: 0, row: 0, oldValue: 'old', newValue: null }, 291 291 + )).toBe(true); 292 292 + }); 293 293 + 294 294 + it('value_is_empty matches undefined', () => { 295 295 + expect(matchesTrigger( 296 296 + { type: 'value_is_empty' }, 297 297 + { column: 0, row: 0, oldValue: 'old', newValue: undefined }, 298 298 + )).toBe(true); 299 299 + }); 300 300 + 301 301 + it('value_equals with numeric string', () => { 302 302 + expect(matchesTrigger( 303 303 + { type: 'value_equals', value: '42' }, 304 304 + { column: 0, row: 0, oldValue: '', newValue: '42' }, 305 305 + )).toBe(true); 306 306 + // String(42) === '42', so number 42 matches value_equals '42' 307 307 + expect(matchesTrigger( 308 308 + { type: 'value_equals', value: '42' }, 309 309 + { column: 0, row: 0, oldValue: '', newValue: 42 }, 310 310 + )).toBe(true); 311 311 + }); 312 312 + 313 313 + it('unknown trigger type returns false', () => { 314 314 + expect(matchesTrigger( 315 315 + { type: 'unknown_type' as any }, 316 316 + { column: 0, row: 0, oldValue: '', newValue: 'x' }, 317 317 + )).toBe(false); 318 318 + }); 319 319 + }); 320 320 + 321 321 + describe('findMatchingRules — edge cases', () => { 322 322 + it('returns empty for empty state', () => { 323 323 + const state = createAutomationState(); 324 324 + expect(findMatchingRules(state, { column: 0, row: 0, oldValue: '', newValue: 'x' })).toEqual([]); 325 325 + }); 326 326 + 327 327 + it('multiple rules can match same event', () => { 328 328 + let state = createAutomationState(); 329 329 + state = addRule(state, 'R1', { type: 'cell_changed' }, [{ type: 'set_timestamp' }]); 330 330 + state = addRule(state, 'R2', { type: 'cell_changed' }, [{ type: 'set_color' }]); 331 331 + const matches = findMatchingRules(state, { column: 0, row: 0, oldValue: '', newValue: 'x' }); 332 332 + expect(matches).toHaveLength(2); 333 333 + }); 334 334 + 335 335 + it('unlimited maxExecutions (0) never exhausts', () => { 336 336 + let state = createAutomationState(); 337 337 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 338 338 + for (let i = 0; i < 100; i++) { 339 339 + state = recordExecution(state, state.rules[0].id); 340 340 + } 341 341 + expect(findMatchingRules(state, { column: 0, row: 0, oldValue: '', newValue: 'x' })).toHaveLength(1); 342 342 + }); 343 343 + }); 344 344 + 345 345 + describe('recordExecution — edge cases', () => { 346 346 + it('does not affect other rules', () => { 347 347 + let state = createAutomationState(); 348 348 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 349 349 + state = addRule(state, 'R2', { type: 'cell_changed' }, []); 350 350 + state = recordExecution(state, state.rules[0].id); 351 351 + expect(state.rules[0].executionCount).toBe(1); 352 352 + expect(state.rules[1].executionCount).toBe(0); 353 353 + }); 354 354 + 355 355 + it('handles unknown rule ID gracefully', () => { 356 356 + let state = createAutomationState(); 357 357 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 358 358 + const result = recordExecution(state, 'nonexistent'); 359 359 + expect(result.rules[0].executionCount).toBe(0); 360 360 + }); 361 361 + }); 362 362 + 363 363 + describe('duplicateRule — edge cases', () => { 364 364 + it('duplicate preserves trigger and actions', () => { 365 365 + let state = createAutomationState(); 366 366 + state = addRule(state, 'R1', { type: 'value_greater_than', column: 3, value: '50' }, [ 367 367 + { type: 'set_color', color: '#ff0000' }, 368 368 + ]); 369 369 + state = duplicateRule(state, state.rules[0].id); 370 370 + const copy = state.rules[1]; 371 371 + expect(copy.trigger.type).toBe('value_greater_than'); 372 372 + expect(copy.trigger.column).toBe(3); 373 373 + expect(copy.trigger.value).toBe('50'); 374 374 + expect(copy.actions[0].type).toBe('set_color'); 375 375 + expect(copy.actions[0].color).toBe('#ff0000'); 376 376 + }); 377 377 + 378 378 + it('duplicate preserves enabled state', () => { 379 379 + let state = createAutomationState(); 380 380 + state = addRule(state, 'R1', { type: 'cell_changed' }, []); 381 381 + state = toggleRule(state, state.rules[0].id); // disable 382 382 + state = duplicateRule(state, state.rules[0].id); 383 383 + expect(state.rules[1].enabled).toBe(false); 384 384 + }); 385 385 + });

+98

tests/range-highlight.test.ts

reviewed

··· 175 175 expect(result).toEqual([]); 176 176 }); 177 177 }); 178 178 + 179 179 + // ===================================================================== 180 180 + // Edge cases 181 181 + // ===================================================================== 182 182 + 183 183 + describe('extractFormulaRanges — edge cases', () => { 184 184 + it('handles empty string', () => { 185 185 + expect(extractFormulaRanges('')).toEqual([]); 186 186 + }); 187 187 + 188 188 + it('handles formula with only numbers and operators', () => { 189 189 + expect(extractFormulaRanges('1+2*3')).toEqual([]); 190 190 + }); 191 191 + 192 192 + it('handles string literals (should not extract refs inside strings)', () => { 193 193 + // Strings in formulas are in quotes, but extractFormulaRanges operates on raw formula text 194 194 + // The regex may pick up refs inside strings — testing actual behavior 195 195 + const result = extractFormulaRanges('"A1"'); 196 196 + // A1 inside quotes may or may not be extracted depending on implementation 197 197 + expect(Array.isArray(result)).toBe(true); 198 198 + }); 199 199 + 200 200 + it('extracts mixed absolute and relative references', () => { 201 201 + const result = extractFormulaRanges('$A1+B$2+$C$3'); 202 202 + expect(result).toHaveLength(3); 203 203 + expect(result[0].ref).toBe('$A1'); 204 204 + expect(result[1].ref).toBe('B$2'); 205 205 + expect(result[2].ref).toBe('$C$3'); 206 206 + }); 207 207 + 208 208 + it('extracts cross-sheet range references', () => { 209 209 + const result = extractFormulaRanges('Sheet2!A1:B5'); 210 210 + expect(result.some(r => r.ref.includes('Sheet2'))).toBe(true); 211 211 + }); 212 212 + 213 213 + it('handles multiple cross-sheet refs', () => { 214 214 + const result = extractFormulaRanges('Sheet1!A1+Sheet2!B2'); 215 215 + expect(result.length).toBeGreaterThanOrEqual(2); 216 216 + }); 217 217 + 218 218 + it('extracts large column refs like AA1, AZ99', () => { 219 219 + const result = extractFormulaRanges('AA1+AZ99'); 220 220 + expect(result.some(r => r.ref === 'AA1')).toBe(true); 221 221 + expect(result.some(r => r.ref === 'AZ99')).toBe(true); 222 222 + }); 223 223 + 224 224 + it('handles a complex nested formula', () => { 225 225 + const result = extractFormulaRanges('IF(AND(A1>0,B1<100),SUM(C1:C10),D1)'); 226 226 + expect(result.some(r => r.ref === 'A1')).toBe(true); 227 227 + expect(result.some(r => r.ref === 'B1')).toBe(true); 228 228 + expect(result.some(r => r.ref === 'C1:C10')).toBe(true); 229 229 + expect(result.some(r => r.ref === 'D1')).toBe(true); 230 230 + }); 231 231 + 232 232 + it('does not extract TRUE or FALSE as references', () => { 233 233 + const result = extractFormulaRanges('IF(TRUE,A1,FALSE)'); 234 234 + expect(result.every(r => r.ref !== 'TRUE' && r.ref !== 'FALSE')).toBe(true); 235 235 + }); 236 236 + }); 237 237 + 238 238 + describe('assignRangeColors — edge cases', () => { 239 239 + it('all 6 unique refs get distinct colors', () => { 240 240 + const ranges = Array.from({ length: 6 }, (_, i) => ({ 241 241 + ref: `${String.fromCharCode(65 + i)}1`, 242 242 + startIndex: i * 3, 243 243 + endIndex: i * 3 + 2, 244 244 + })); 245 245 + const result = assignRangeColors(ranges); 246 246 + const colors = new Set(result.map(r => r.color)); 247 247 + expect(colors.size).toBe(6); 248 248 + }); 249 249 + 250 250 + it('colors come from RANGE_COLORS palette', () => { 251 251 + const ranges = [{ ref: 'A1', startIndex: 0, endIndex: 2 }]; 252 252 + const result = assignRangeColors(ranges); 253 253 + expect(RANGE_COLORS).toContain(result[0].color); 254 254 + }); 255 255 + 256 256 + it('handles single range', () => { 257 257 + const result = assignRangeColors([{ ref: 'A1:B5', startIndex: 0, endIndex: 5 }]); 258 258 + expect(result).toHaveLength(1); 259 259 + expect(result[0].color).toBeTruthy(); 260 260 + expect(result[0].ref).toBe('A1:B5'); 261 261 + }); 262 262 + 263 263 + it('duplicate refs in sequence share same color', () => { 264 264 + const ranges = [ 265 265 + { ref: 'A1', startIndex: 0, endIndex: 2 }, 266 266 + { ref: 'B1', startIndex: 3, endIndex: 5 }, 267 267 + { ref: 'A1', startIndex: 6, endIndex: 8 }, 268 268 + { ref: 'B1', startIndex: 9, endIndex: 11 }, 269 269 + ]; 270 270 + const result = assignRangeColors(ranges); 271 271 + expect(result[0].color).toBe(result[2].color); 272 272 + expect(result[1].color).toBe(result[3].color); 273 273 + expect(result[0].color).not.toBe(result[1].color); 274 274 + }); 275 275 + });

+131

tests/theming.test.ts

reviewed

··· 146 146 }); 147 147 }); 148 148 }); 149 149 + 150 150 + // ===================================================================== 151 151 + // Edge cases 152 152 + // ===================================================================== 153 153 + 154 154 + describe('Theming — edge cases', () => { 155 155 + describe('BUILT_IN_THEMES structure', () => { 156 156 + it('each theme has unique id', () => { 157 157 + const ids = BUILT_IN_THEMES.map(t => t.id); 158 158 + expect(new Set(ids).size).toBe(ids.length); 159 159 + }); 160 160 + 161 161 + it('each theme has valid base type', () => { 162 162 + for (const theme of BUILT_IN_THEMES) { 163 163 + expect(['light', 'dark']).toContain(theme.base); 164 164 + } 165 165 + }); 166 166 + 167 167 + it('all themes are builtIn', () => { 168 168 + for (const theme of BUILT_IN_THEMES) { 169 169 + expect(theme.builtIn).toBe(true); 170 170 + } 171 171 + }); 172 172 + 173 173 + it('includes sepia, forest, midnight, and rose themes', () => { 174 174 + const ids = BUILT_IN_THEMES.map(t => t.id); 175 175 + expect(ids).toContain('sepia'); 176 176 + expect(ids).toContain('forest'); 177 177 + expect(ids).toContain('midnight'); 178 178 + expect(ids).toContain('rose'); 179 179 + }); 180 180 + }); 181 181 + 182 182 + describe('getBuiltInTheme edge cases', () => { 183 183 + it('returns null for empty string', () => { 184 184 + expect(getBuiltInTheme('')).toBeNull(); 185 185 + }); 186 186 + 187 187 + it('is case-sensitive (returns null for "Light")', () => { 188 188 + expect(getBuiltInTheme('Light')).toBeNull(); 189 189 + }); 190 190 + }); 191 191 + 192 192 + describe('generateCssVars edge cases', () => { 193 193 + it('values match the input colors exactly', () => { 194 194 + const colors = BUILT_IN_THEMES[0].colors; 195 195 + const vars = generateCssVars(colors); 196 196 + expect(vars['--color-accent']).toBe(colors.accent); 197 197 + expect(vars['--color-bg']).toBe(colors.bg); 198 198 + expect(vars['--color-surface']).toBe(colors.surface); 199 199 + expect(vars['--color-text']).toBe(colors.text); 200 200 + expect(vars['--color-text-muted']).toBe(colors.textMuted); 201 201 + expect(vars['--color-border']).toBe(colors.border); 202 202 + }); 203 203 + 204 204 + it('works with non-oklch values', () => { 205 205 + const vars = generateCssVars({ 206 206 + accent: '#ff0000', bg: '#fff', surface: '#eee', 207 207 + text: '#000', textMuted: '#666', border: '#ccc', 208 208 + }); 209 209 + expect(vars['--color-accent']).toBe('#ff0000'); 210 210 + }); 211 211 + }); 212 212 + 213 213 + describe('createCustomTheme edge cases', () => { 214 214 + it('overrides multiple color properties', () => { 215 215 + const custom = createCustomTheme('Multi', 'light', { 216 216 + accent: 'oklch(0.7 0.2 300)', 217 217 + bg: 'oklch(0.99 0 0)', 218 218 + border: 'oklch(0.9 0 0)', 219 219 + }); 220 220 + expect(custom.colors.accent).toBe('oklch(0.7 0.2 300)'); 221 221 + expect(custom.colors.bg).toBe('oklch(0.99 0 0)'); 222 222 + expect(custom.colors.border).toBe('oklch(0.9 0 0)'); 223 223 + // Non-overridden should come from base 224 224 + const lightTheme = BUILT_IN_THEMES.find(t => t.id === 'light')!; 225 225 + expect(custom.colors.text).toBe(lightTheme.colors.text); 226 226 + }); 227 227 + 228 228 + it('overrides no properties (inherits all from base)', () => { 229 229 + const custom = createCustomTheme('Clone', 'dark', {}); 230 230 + const darkTheme = BUILT_IN_THEMES.find(t => t.id === 'dark')!; 231 231 + expect(custom.colors).toEqual(darkTheme.colors); 232 232 + }); 233 233 + 234 234 + it('inherits base property from base theme', () => { 235 235 + const custom = createCustomTheme('DarkClone', 'dark', {}); 236 236 + expect(custom.base).toBe('dark'); 237 237 + }); 238 238 + }); 239 239 + 240 240 + describe('resolveTheme edge cases', () => { 241 241 + it('returns light when given empty string', () => { 242 242 + expect(resolveTheme('').id).toBe('light'); 243 243 + }); 244 244 + 245 245 + it('prefers custom theme over built-in with same ID', () => { 246 246 + // getAllThemes puts built-ins first, then custom — find() returns first match 247 247 + // So built-in 'light' would be found before a custom 'light' 248 248 + const custom: Theme = { 249 249 + id: 'custom-override', name: 'Override', base: 'dark', 250 250 + builtIn: false, colors: BUILT_IN_THEMES[1].colors, 251 251 + }; 252 252 + expect(resolveTheme('custom-override', [custom]).name).toBe('Override'); 253 253 + }); 254 254 + }); 255 255 + 256 256 + describe('deleteCustomTheme edge cases', () => { 257 257 + it('returns same array when ID not found', () => { 258 258 + const themes: Theme[] = [ 259 259 + { id: 'custom-1', name: 'C1', base: 'dark', builtIn: false, colors: BUILT_IN_THEMES[1].colors }, 260 260 + ]; 261 261 + const result = deleteCustomTheme(themes, 'nonexistent'); 262 262 + expect(result).toHaveLength(1); 263 263 + }); 264 264 + 265 265 + it('handles empty array', () => { 266 266 + expect(deleteCustomTheme([], 'anything')).toEqual([]); 267 267 + }); 268 268 + 269 269 + it('deletes all custom themes one by one', () => { 270 270 + const themes: Theme[] = [ 271 271 + { id: 'c1', name: 'C1', base: 'dark', builtIn: false, colors: BUILT_IN_THEMES[1].colors }, 272 272 + { id: 'c2', name: 'C2', base: 'light', builtIn: false, colors: BUILT_IN_THEMES[0].colors }, 273 273 + ]; 274 274 + let result = deleteCustomTheme(themes, 'c1'); 275 275 + result = deleteCustomTheme(result, 'c2'); 276 276 + expect(result).toEqual([]); 277 277 + }); 278 278 + }); 279 279 + });