jettypod 4.1.2 → 4.1.4

package/features/work-tracking/prototype-tracking.test.js

@@ -1,485 +0,0 @@
-const { createTestEnvironment } = require('../../lib/test-helpers');
-const { getDb, closeDb, resetDb } = require('../../lib/database');
-
-describe('Multi-level Prototype Tracking', () => {
-  let testEnv;
-  let db;
-
-  beforeEach(() => {
-    resetDb();
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-    db = getDb();
-  });
-
-  afterEach(async () => {
-    
-    
-    await closeDb();
-    testEnv.cleanup();
-    resetDb();
-  });
-
-  describe('Database Schema', () => {
-    test('prototype_files column exists in work_items table', async () => {
-      await new Promise((resolve) => {
-        db.get('SELECT sql FROM sqlite_master WHERE type="table" AND name="work_items"', [], (err, row) => {
-          expect(err).toBeNull();
-          expect(row.sql).toContain('prototype_files');
-          resolve();
-        });
-      });
-    });
-
-    test('discovery_winner column exists in work_items table', async () => {
-      await new Promise((resolve) => {
-        db.get('SELECT sql FROM sqlite_master WHERE type="table" AND name="work_items"', [], (err, row) => {
-          expect(err).toBeNull();
-          expect(row.sql).toContain('discovery_winner');
-          resolve();
-        });
-      });
-    });
-
-    test('prototype_files accepts JSON array', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['proto1.js', 'proto2.js']);
-        db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', prototypeFiles],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT prototype_files FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.prototype_files).toBe(prototypeFiles);
-              expect(JSON.parse(row.prototype_files)).toEqual(['proto1.js', 'proto2.js']);
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('discovery_winner accepts file path', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title, discovery_winner) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', 'prototypes/winner.js'],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT discovery_winner FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.discovery_winner).toBe('prototypes/winner.js');
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('prototype fields allow NULL values', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner) VALUES (?, ?, ?, ?)',
-          ['feature', 'Test Feature', null, null],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.prototype_files).toBeNull();
-              expect(row.discovery_winner).toBeNull();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-  });
-
-  describe('Project-level Prototype Tracking', () => {
-    test('project stores prototypes from discovery', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['prototypes/web.js', 'prototypes/mobile.js']);
-        db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner) VALUES (?, ?, ?, ?)',
-          ['epic', 'Project Discovery', prototypeFiles, 'prototypes/web.js'],
-          function(err) {
-            expect(err).toBeNull();
-            const projectId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [projectId], (err, row) => {
-              expect(err).toBeNull();
-              expect(JSON.parse(row.prototype_files)).toEqual(['prototypes/web.js', 'prototypes/mobile.js']);
-              expect(row.discovery_winner).toBe('prototypes/web.js');
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('project without prototypes has NULL fields', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)',
-          ['epic', 'Project Without Prototypes'],
-          function(err) {
-            expect(err).toBeNull();
-            const projectId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [projectId], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.prototype_files).toBeNull();
-              expect(row.discovery_winner).toBeNull();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-  });
-
-  describe('Epic-level Prototype Tracking', () => {
-    test('epic stores prototypes from architectural decision', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['prototypes/websocket.js', 'prototypes/sse.js']);
-        db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner) VALUES (?, ?, ?, ?)',
-          ['epic', 'Real-time Updates Epic', prototypeFiles, 'WebSockets with Socket.io'],
-          function(err) {
-            expect(err).toBeNull();
-            const epicId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [epicId], (err, row) => {
-              expect(err).toBeNull();
-              expect(JSON.parse(row.prototype_files)).toEqual(['prototypes/websocket.js', 'prototypes/sse.js']);
-              expect(row.discovery_winner).toBe('WebSockets with Socket.io');
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('epic without architectural prototypes has NULL fields', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)',
-          ['epic', 'Simple Epic'],
-          function(err) {
-            expect(err).toBeNull();
-            const epicId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [epicId], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.prototype_files).toBeNull();
-              expect(row.discovery_winner).toBeNull();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-  });
-
-  describe('Feature-level Prototype Tracking', () => {
-    test('feature stores prototypes from discovery phase', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['prototypes/option-a.js', 'prototypes/option-b.js']);
-        db.run('INSERT INTO work_items (type, title, phase, prototype_files, discovery_winner) VALUES (?, ?, ?, ?, ?)',
-          ['feature', 'Test Feature', 'implementation', prototypeFiles, 'prototypes/option-a.js'],
-          function(err) {
-            expect(err).toBeNull();
-            const featureId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner, phase FROM work_items WHERE id = ?', [featureId], (err, row) => {
-              expect(err).toBeNull();
-              expect(JSON.parse(row.prototype_files)).toEqual(['prototypes/option-a.js', 'prototypes/option-b.js']);
-              expect(row.discovery_winner).toBe('prototypes/option-a.js');
-              expect(row.phase).toBe('implementation');
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('feature transition to implementation preserves prototypes', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['proto1.js', 'proto2.js']);
-
-        // Create feature in discovery with prototypes
-        db.run('INSERT INTO work_items (type, title, phase, mode, prototype_files, discovery_winner) VALUES (?, ?, ?, ?, ?, ?)',
-          ['feature', 'Test Feature', 'discovery', 'discovery', prototypeFiles, 'proto1.js'],
-          function(err) {
-            const featureId = this.lastID;
-
-            // Transition to implementation (simulate work implement command)
-            db.run('UPDATE work_items SET phase = ?, mode = ? WHERE id = ?',
-              ['implementation', 'speed', featureId],
-              () => {
-                db.get('SELECT phase, mode, prototype_files, discovery_winner FROM work_items WHERE id = ?', [featureId], (err, row) => {
-                  expect(row.phase).toBe('implementation');
-                  expect(row.mode).toBe('speed');
-                  expect(JSON.parse(row.prototype_files)).toEqual(['proto1.js', 'proto2.js']);
-                  expect(row.discovery_winner).toBe('proto1.js');
-                  resolve();
-                });
-              }
-            );
-          }
-        );
-      });
-    });
-
-    test('feature without prototypes has NULL fields', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
-          ['feature', 'Simple Feature', 'discovery', 'discovery'],
-          function(err) {
-            expect(err).toBeNull();
-            const featureId = this.lastID;
-
-            db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [featureId], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.prototype_files).toBeNull();
-              expect(row.discovery_winner).toBeNull();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-  });
-
-  describe('Edge Cases', () => {
-    test('empty JSON array is valid', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify([]);
-        db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', prototypeFiles],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT prototype_files FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(JSON.parse(row.prototype_files)).toEqual([]);
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('invalid JSON is stored as-is', async () => {
-      await new Promise((resolve) => {
-        const invalidJson = 'not valid json';
-        db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', invalidJson],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT prototype_files FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(row.prototype_files).toBe(invalidJson);
-              // Parsing should throw
-              expect(() => JSON.parse(row.prototype_files)).toThrow();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('empty string for discovery_winner', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title, discovery_winner) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', ''],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT discovery_winner FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(row.discovery_winner).toBe('');
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('long file paths are stored correctly', async () => {
-      await new Promise((resolve) => {
-        const longPath = 'prototypes/' + 'a'.repeat(500) + '/winner.js';
-        db.run('INSERT INTO work_items (type, title, discovery_winner) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', longPath],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT discovery_winner FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              expect(row.discovery_winner).toBe(longPath);
-              expect(row.discovery_winner.length).toBe(longPath.length);
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('JSON with special characters', async () => {
-      await new Promise((resolve) => {
-        const specialFiles = JSON.stringify(['proto "quoted".js', "proto 'single'.js", 'proto\\backslash.js']);
-        db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)',
-          ['feature', 'Test Feature', specialFiles],
-          function(err) {
-            expect(err).toBeNull();
-
-            db.get('SELECT prototype_files FROM work_items WHERE id = ?', [this.lastID], (err, row) => {
-              const parsed = JSON.parse(row.prototype_files);
-              expect(parsed).toEqual(['proto "quoted".js', "proto 'single'.js", 'proto\\backslash.js']);
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('multiple work items with same prototypes', async () => {
-      await new Promise((resolve) => {
-        const prototypeFiles = JSON.stringify(['proto1.js', 'proto2.js']);
-
-        db.serialize(() => {
-          db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)', ['feature', 'Feature 1', prototypeFiles]);
-          db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)', ['feature', 'Feature 2', prototypeFiles]);
-          db.run('INSERT INTO work_items (type, title, prototype_files) VALUES (?, ?, ?)', ['epic', 'Epic 1', prototypeFiles], () => {
-            db.all('SELECT COUNT(*) as count FROM work_items WHERE prototype_files = ?', [prototypeFiles], (err, rows) => {
-              expect(rows[0].count).toBe(3);
-              resolve();
-            });
-          });
-        });
-      });
-    });
-  });
-
-  describe('Backwards Compatibility', () => {
-    test('existing work items without prototype fields work correctly', async () => {
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title, status) VALUES (?, ?, ?)',
-          ['feature', 'Legacy Feature', 'backlog'],
-          function(err) {
-            expect(err).toBeNull();
-            const featureId = this.lastID;
-
-            db.get('SELECT * FROM work_items WHERE id = ?', [featureId], (err, row) => {
-              expect(err).toBeNull();
-              expect(row.title).toBe('Legacy Feature');
-              expect(row.status).toBe('backlog');
-              expect(row.prototype_files).toBeNull();
-              expect(row.discovery_winner).toBeNull();
-              resolve();
-            });
-          }
-        );
-      });
-    });
-
-    test('can add prototypes to existing work item', async () => {
-      await new Promise((resolve) => {
-        // Create without prototypes
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)',
-          ['feature', 'Existing Feature'],
-          function(err) {
-            const featureId = this.lastID;
-
-            // Later add prototypes
-            const prototypeFiles = JSON.stringify(['new-proto.js']);
-            db.run('UPDATE work_items SET prototype_files = ?, discovery_winner = ? WHERE id = ?',
-              [prototypeFiles, 'new-proto.js', featureId],
-              () => {
-                db.get('SELECT prototype_files, discovery_winner FROM work_items WHERE id = ?', [featureId], (err, row) => {
-                  expect(JSON.parse(row.prototype_files)).toEqual(['new-proto.js']);
-                  expect(row.discovery_winner).toBe('new-proto.js');
-                  resolve();
-                });
-              }
-            );
-          }
-        );
-      });
-    });
-  });
-
-  describe('Multi-level Tracking Integration', () => {
-    test('project, epic, and feature can all have different prototypes', async () => {
-      await new Promise((resolve) => {
-        db.serialize(() => {
-          // Project-level prototypes
-          db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner) VALUES (?, ?, ?, ?)',
-            ['epic', 'Project', JSON.stringify(['project-proto.js']), 'project-proto.js']
-          );
-
-          // Epic-level prototypes
-          db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner, parent_id) VALUES (?, ?, ?, ?, ?)',
-            ['epic', 'Epic', JSON.stringify(['epic-proto.js']), 'epic-proto.js', 1]
-          );
-
-          // Feature-level prototypes
-          db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner, parent_id, epic_id) VALUES (?, ?, ?, ?, ?, ?)',
-            ['feature', 'Feature', JSON.stringify(['feature-proto.js']), 'feature-proto.js', 2, 2],
-            () => {
-              db.all('SELECT type, title, prototype_files, discovery_winner FROM work_items ORDER BY id', [], (err, rows) => {
-                expect(rows.length).toBe(3);
-
-                expect(rows[0].type).toBe('epic');
-                expect(JSON.parse(rows[0].prototype_files)).toEqual(['project-proto.js']);
-                expect(rows[0].discovery_winner).toBe('project-proto.js');
-
-                expect(rows[1].type).toBe('epic');
-                expect(JSON.parse(rows[1].prototype_files)).toEqual(['epic-proto.js']);
-                expect(rows[1].discovery_winner).toBe('epic-proto.js');
-
-                expect(rows[2].type).toBe('feature');
-                expect(JSON.parse(rows[2].prototype_files)).toEqual(['feature-proto.js']);
-                expect(rows[2].discovery_winner).toBe('feature-proto.js');
-
-                resolve();
-              });
-            }
-          );
-        });
-      });
-    });
-
-    test('child inherits no prototypes from parent by default', async () => {
-      await new Promise((resolve) => {
-        db.serialize(() => {
-          // Epic with prototypes
-          db.run('INSERT INTO work_items (type, title, prototype_files, discovery_winner) VALUES (?, ?, ?, ?)',
-            ['epic', 'Parent Epic', JSON.stringify(['parent-proto.js']), 'parent-proto.js'],
-            function() {
-              const epicId = this.lastID;
-
-              // Feature without prototypes
-              db.run('INSERT INTO work_items (type, title, parent_id, epic_id) VALUES (?, ?, ?, ?)',
-                ['feature', 'Child Feature', epicId, epicId],
-                function() {
-                  const featureId = this.lastID;
-
-                  db.all('SELECT id, type, prototype_files, discovery_winner FROM work_items WHERE id IN (?, ?)',
-                    [epicId, featureId],
-                    (err, rows) => {
-                      const epic = rows.find(r => r.type === 'epic');
-                      const feature = rows.find(r => r.type === 'feature');
-
-                      expect(JSON.parse(epic.prototype_files)).toEqual(['parent-proto.js']);
-                      expect(epic.discovery_winner).toBe('parent-proto.js');
-
-                      expect(feature.prototype_files).toBeNull();
-                      expect(feature.discovery_winner).toBeNull();
-
-                      resolve();
-                    }
-                  );
-                }
-              );
-            }
-          );
-        });
-      });
-    });
-  });
-});