Merge branch 'main' of https://github.com/stackpress/idea

Author: cblanquera

packages/idea-parser/tests/Compiler.test.ts

@@ -0,0 +1,102 @@
+import { describe, it } from 'mocha';
+import { expect, use } from 'chai';
+import Compiler from '../../idea-parser/src/Compiler'
+import { 
+    DataToken, 
+    DeclarationToken, 
+    IdentifierToken, 
+    ImportToken, 
+    SchemaToken
+} from '../src/types';
+
+describe('Compiler Test', () => {
+
+    // Line 46
+    it('Should throw an exception with the message "Invalid data token type" when an invalid token type is encountered', () => {
+        const invalidToken = { type: 'InvalidType' } as unknown as DataToken;
+        expect(() => Compiler.data(invalidToken)).to.throw('Invalid data token type');
+    });
+
+    // Line 54
+    it('Should throw an exception with the message "Invalid Enum" when an invalid enum is encountered', () => {
+        const invalidEnumToken = { kind: 'notAnEnum', declarations: [] } as unknown as DeclarationToken;
+        expect(() => Compiler.enum(invalidEnumToken)).to.throw('Invalid Enum');
+    });
+
+    // Line 86
+    it('Should throw an exception with the message "Unknown reference {token.name}" when references is an empty object', () => {
+        const token = { name: 'someReference' } as IdentifierToken;
+        expect(() => Compiler.identifier(token, {})).to.throw('Unknown reference someReference');
+    });
+
+
+    // Line 109
+    it('Should throw an exception with the message "Expecting a columns property" when the columns property is missing', () => {
+        const tokenWithoutColumns = { kind: 'model',
+            declarations: [{
+                id: { name: 'TestModel' },
+                init: { properties: [] }
+            }]
+        } as unknown as DeclarationToken;
+        expect(() => Compiler.model(tokenWithoutColumns)).to.throw('Expecting a columns property');
+    });
+
+    // Line 152 
+    it('Should throw an exception with the message "Invalid Plugin" when an invalid plugin is encountered', () => {
+        const invalidPluginToken = { kind: 'notAPlugin', declarations: [] } as unknown as DeclarationToken;
+        expect(() => Compiler.plugin(invalidPluginToken)).to.throw('Invalid Plugin');
+    });
+
+    // Line 168
+    it('Should throw an exception with the message "Invalid Prop" when an invalid property is encountered', () => {
+        const invalidPropToken = { kind: 'notAProp', declarations: [] } as unknown as DeclarationToken;
+        expect(() => Compiler.prop(invalidPropToken)).to.throw('Invalid Prop');
+    });
+
+    // Line 184
+    it('Should throw an exception with the message "Invalid Schema" when an invalid schema is encountered', () => {
+        const invalidSchemaToken = { kind: 'notASchema', body: [] } as unknown as SchemaToken;
+        expect(() => Compiler.schema(invalidSchemaToken)).to.throw('Invalid Schema');
+    });
+
+    // Line 205
+    it('Should throw an exception with the message "Duplicate key" when a duplicate key is encountered in the schema', () => {
+        const duplicateKeyToken = {
+            kind: 'schema',
+            body: [
+                {
+                    kind: 'enum',
+                    declarations: [{
+                        id: { name: 'DuplicateKey' },
+                        init: { properties: [{ key: { name: 'key1' }, value: { value: 'value1' } }] }
+                    }]
+                },
+                {
+                    kind: 'enum',
+                    declarations: [{
+                        id: { name: 'DuplicateKey' },
+                        init: { properties: [{ key: { name: 'key2' }, value: { value: 'value2' } }] }
+                    }]
+                }
+            ]
+        } as unknown as SchemaToken;
+        expect(() => Compiler.schema(duplicateKeyToken)).to.throw('Duplicate DuplicateKey');
+    });
+
+    // Line 260
+    it('Should throw an exception with the message "Invalid Type" when an invalid type is encountered', () => {
+        const invalidTypeToken = { kind: 'notAType', declarations: [] } as unknown as DeclarationToken;
+        expect(() => Compiler.type(invalidTypeToken)).to.throw('Invalid Type');
+    });
+    
+    // Line 304
+    it('Should throw an exception with the message "Invalid Import" when an invalid import is encountered', () => {
+        const invalidImportToken = { type: 'NotAnImportDeclaration', source: { value: './invalid.idea' } } as unknown as ImportToken;
+        expect(() => Compiler.use(invalidImportToken)).to.throw('Invalid Import');
+    });
+    
+    
+
+
+
+})

packages/idea-parser/tests/EnumTree.test.ts

@@ -6,11 +6,47 @@ import EnumTree from '../src/trees/EnumTree';
 
 use(deepEqualInAnyOrder);
 
+/*
+* The cleanAST function is used to remove start and end
+* properties from ASTs for comparison.
+*/
+const cleanAST = (node: any) => {
+  if (typeof node === 'object' && node !== null) {
+    const { start, end, ...rest } = node;
+    return Object.keys(rest).reduce((acc, key) => {
+      acc[key] = Array.isArray(rest[key])
+        ? rest[key].map(cleanAST)
+        : cleanAST(rest[key]);
+      return acc;
+    }, {});
+  }
+  return node;
+};
+
 describe('Enum Tree', () => {
   it('Should parse Enums', async () => {
-    const actual = EnumTree.parse(fs.readFileSync(`${__dirname}/fixtures/enum.idea`, 'utf8'));
-    const expected = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/enum.json`, 'utf8'));
+    const actualRaw = EnumTree.parse(fs.readFileSync(`${__dirname}/fixtures/enum.idea`, 'utf8'));
+    const expectedRaw = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/enum.json`, 'utf8'));
+
+    const actual = cleanAST(actualRaw);
+    const expected = cleanAST(expectedRaw);
     //console.log(JSON.stringify(actual, null, 2));
     expect(actual).to.deep.equalInAnyOrder(expected);
   });
+
+  // Line 37
+  it('Should throw an error when the input is an empty string', () => {
+    expect(() => {
+      const lexerMock = {
+        expect: (tokenType: string) => { throw new Error('Unexpected end of input'); },
+        load: () => {}
+      };
+      const enumTree = new EnumTree();
+      (enumTree as any)._lexer = lexerMock;
+      enumTree.parse('');
+    }).to.throw(Error, 'Unexpected end of input');
+  });
+
+
+
 });

packages/idea-parser/tests/Lexer.test.ts

@@ -2,7 +2,8 @@ import type {
   LiteralToken, 
   ObjectToken, 
   ArrayToken, 
-  UnknownToken 
+  UnknownToken, 
+  Token
 } from '../src/types';
 
 import { describe, it } from 'mocha';
@@ -254,4 +255,51 @@ describe('Lexer/Compiler', () => {
       expect(token.end).to.equal(45);
     })();
   });
+
+  // Line 18
+  it('Should handle an empty input string and return an appropriate token', () => {
+    const lexer = new Lexer();
+    lexer.load('');
+    const token = lexer.read();
+    expect(token).to.be.undefined;
+  });
+
+  // Line 58
+  it('Should throw an exception for an unknown definition key', () => {
+    const lexer = new Lexer();
+    expect(() => lexer.expect('unknownKey')).to.throw('Unknown definition unknownKey');
+  });
+
+  // Line 117
+  it('Should handle the case when keys parameter is explicitly passed as undefined', () => {
+  const lexer = new Lexer();
+  lexer.define('literal', (code, start) => {
+    if (code.startsWith('42', start)) {
+      return { type: 'Literal', value: 42, start, end: start + 2 } as Token;
+    }
+    return undefined;
+  });
+  lexer.load('42');
+  const token = lexer.match('42', 0, undefined);
+  expect(token).to.deep.equal({ type: 'Literal', value: 42, start: 0, end: 2 });
+  });
+
+  // Line 121
+  it('Should throw an exception when a key is missing from the dictionary', () => {
+    const lexer = new Lexer();
+    lexer.load('some code');
+    expect(() => lexer.match('some code', 0, ['missingKey'])).to.throw('Unknown definition missingKey');
+  });
+
+  // Line 174
+  it('Should return an empty string when start and end are the same', () => {
+    const lexer = new Lexer();
+    lexer.load('some code');
+    const result = lexer.substring(5, 5);
+    expect(result).to.equal('');
+  });
+
+
+
+
 });

packages/idea-parser/tests/ModelTree.test.ts

@@ -6,11 +6,52 @@ import ModelTree from '../src/trees/ModelTree';
 
 use(deepEqualInAnyOrder);
 
+/*
+* The cleanAST function is used to remove start and end
+* properties from ASTs for comparison.
+*/
+const cleanAST = (node: any) => {
+  if (typeof node === 'object' && node !== null) {
+    const { start, end, ...rest } = node;
+    return Object.keys(rest).reduce((acc, key) => {
+      acc[key] = Array.isArray(rest[key])
+        ? rest[key].map(cleanAST)
+        : cleanAST(rest[key]);
+      return acc;
+    }, {});
+  }
+  return node;
+};
+
 describe('Model Tree', () => {
   it('Should parse Model', async () => {
-    const actual = ModelTree.parse(fs.readFileSync(`${__dirname}/fixtures/model.idea`, 'utf8'));
-    const expected = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/model.json`, 'utf8'));
+    const actualRaw = ModelTree.parse(fs.readFileSync(`${__dirname}/fixtures/model.idea`, 'utf8'));
+    const expectedRaw = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/model.json`, 'utf8'));
+
+    const actual = cleanAST(actualRaw);
+    const expected = cleanAST(expectedRaw);
     //console.log(JSON.stringify(actual, null, 2));
     expect(actual).to.deep.equalInAnyOrder(expected);
   });
+
+  // Line 37
+  it('Should throw an error if the lexer does not return an IdentifierToken when expecting CapitalIdentifier', () => {
+    const lexerMock = {
+      expect: (tokenType: string) => {
+        if (tokenType === 'CapitalIdentifier') {
+          throw new Error('Expected CapitalIdentifier but got something else');
+        }
+      },
+      load: () => {}
+    };
+  
+    const modelTree = new ModelTree();
+    modelTree['_lexer'] = lexerMock as any;
+  
+    expect(() => modelTree.parse('model foobar')).to.throw('Expected CapitalIdentifier but got something else');
+  });
+
+
+
+
 });

packages/idea-parser/tests/PluginTree.test.ts

@@ -6,11 +6,45 @@ import PluginTree from '../src/trees/PluginTree';
 
 use(deepEqualInAnyOrder);
 
+/*
+* The cleanAST function is used to remove start and end
+* properties from ASTs for comparison.
+*/
+const cleanAST = (node: any) => {
+  if (typeof node === 'object' && node !== null) {
+    const { start, end, ...rest } = node;
+    return Object.keys(rest).reduce((acc, key) => {
+      acc[key] = Array.isArray(rest[key])
+        ? rest[key].map(cleanAST)
+        : cleanAST(rest[key]);
+      return acc;
+    }, {});
+  }
+  return node;
+};
+
 describe('Plugin Tree', () => {
   it('Should parse Plugin', async () => {
-    const actual = PluginTree.parse(fs.readFileSync(`${__dirname}/fixtures/plugin.idea`, 'utf8'));
-    const expected = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/plugin.json`, 'utf8'));
+    const actualRaw = PluginTree.parse(fs.readFileSync(`${__dirname}/fixtures/plugin.idea`, 'utf8'));
+    const expectedRaw = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/plugin.json`, 'utf8'));
+
+    const actual = cleanAST(actualRaw);
+    const expected = cleanAST(expectedRaw);
     //console.log(JSON.stringify(actual, null, 2));
     expect(actual).to.deep.equalInAnyOrder(expected);
   });
+
+  // Line 36
+  it('Should throw an error when the input code is an empty string', () => {
+    expect(() => {
+      const lexerMock = {
+        expect: (tokenType: string) => { throw new Error('Unexpected end of input'); },
+        load: () => {}
+      };
+      const pluginTree = new PluginTree();
+      (pluginTree as any)._lexer = lexerMock; 
+      pluginTree.parse('');
+    }).to.throw(Error, 'Unexpected end of input');
+  });
+  
 });

packages/idea-parser/tests/PropTree.test.ts

@@ -3,11 +3,48 @@ import { describe, it } from 'mocha';
 import { expect } from 'chai';
 import PropTree from '../src/trees/PropTree';
 
+
+/*
+* The cleanAST function is used to remove start and end
+* properties from ASTs for comparison.
+*/
+const cleanAST = (node: any) => {
+  if (typeof node === 'object' && node !== null) {
+    const { start, end, ...rest } = node;
+    return Object.keys(rest).reduce((acc, key) => {
+      acc[key] = Array.isArray(rest[key])
+        ? rest[key].map(cleanAST)
+        : cleanAST(rest[key]);
+      return acc;
+    }, {});
+  }
+  return node;
+};
+
 describe('Prop Tree', () => {
   it('Should parse Prop', async () => {
-    const actual = PropTree.parse(fs.readFileSync(`${__dirname}/fixtures/prop.idea`, 'utf8'));
-    const expected = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/prop.json`, 'utf8'));
+    const actualRaw = PropTree.parse(fs.readFileSync(`${__dirname}/fixtures/prop.idea`, 'utf8'));
+    const expectedRaw = JSON.parse(fs.readFileSync(`${__dirname}/fixtures/prop.json`, 'utf8'));
+
+    const actual = cleanAST(actualRaw);
+    const expected = cleanAST(expectedRaw);
     //console.log(JSON.stringify(actual, null, 2));
     expect(actual).to.deep.equalInAnyOrder(expected);
   });
+
+  // Line 36
+  it('Should throw an error when the input code is an emty string', () => {
+    expect(() => {
+      const lexerMock = {
+        expect: (tokenType: string) => { throw new Error('Unexpected end of input'); },
+        load: () => {}
+      };
+      const propTree = new PropTree();
+      (propTree as any)._lexer = lexerMock;
+      propTree.parse('');
+    }).to.throw(Error, 'Unexpected end of input');
+  });
+
+
+
 });