From 1c2df5aa5ece7d92f92d07b9332b0544d1823fc9 Mon Sep 17 00:00:00 2001
From: Hezekiah Hendry <hezekiah.hendry@gmail.com>
Date: Wed, 26 Oct 2022 11:16:33 -0400
Subject: [PATCH 1/2] test: improve coverage

---
 README.md                                     |   1 +
 tests/lib/structures/FunctionParser.test.ts   |  13 ++
 tests/lib/structures/NamespaceParser.test.ts  |  13 ++
 tests/lib/structures/TypeAliasParser.test.ts  |  13 ++
 tests/lib/structures/VariableParser.test.ts   |  13 ++
 .../ClassConstructorParser.test.ts            | 197 +++++++++++++++++
 .../class-parser/ClassMethodParser.test.ts    | 207 ++++++++++++++++++
 .../class-parser/ClassParser.test.ts          |  13 ++
 .../class-parser/ClassPropertyParser.test.ts  |  13 ++
 .../structures/enum-parser/EnumMember.test.ts |  13 ++
 .../structures/enum-parser/EnumParser.test.ts |  13 ++
 .../InterfaceMethodParser.test.ts             |  13 ++
 .../interface-parser/InterfaceParser.test.ts  |  13 ++
 .../InterfacePropertyParser.test.ts           |  13 ++
 .../lib/structures/misc/CommentParser.test.ts | 140 ++++++++++++
 .../structures/misc/ParameterParser.test.ts   | 119 ++++++++++
 .../structures/misc/SignatureParser.test.ts   | 149 +++++++++++++
 .../lib/structures/misc/SourceParser.test.ts  | 114 ++++++++++
 .../misc/TypeParameterParser.test.ts          | 114 ++++++++++
 .../type-parsers/IntrinsicTypeParser.test.ts  |  86 ++++++++
 vitest.config.ts                              |   1 +
 21 files changed, 1271 insertions(+)
 create mode 100644 tests/lib/structures/FunctionParser.test.ts
 create mode 100644 tests/lib/structures/NamespaceParser.test.ts
 create mode 100644 tests/lib/structures/TypeAliasParser.test.ts
 create mode 100644 tests/lib/structures/VariableParser.test.ts
 create mode 100644 tests/lib/structures/class-parser/ClassConstructorParser.test.ts
 create mode 100644 tests/lib/structures/class-parser/ClassMethodParser.test.ts
 create mode 100644 tests/lib/structures/class-parser/ClassParser.test.ts
 create mode 100644 tests/lib/structures/class-parser/ClassPropertyParser.test.ts
 create mode 100644 tests/lib/structures/enum-parser/EnumMember.test.ts
 create mode 100644 tests/lib/structures/enum-parser/EnumParser.test.ts
 create mode 100644 tests/lib/structures/interface-parser/InterfaceMethodParser.test.ts
 create mode 100644 tests/lib/structures/interface-parser/InterfaceParser.test.ts
 create mode 100644 tests/lib/structures/interface-parser/InterfacePropertyParser.test.ts
 create mode 100644 tests/lib/structures/misc/CommentParser.test.ts
 create mode 100644 tests/lib/structures/misc/ParameterParser.test.ts
 create mode 100644 tests/lib/structures/misc/SignatureParser.test.ts
 create mode 100644 tests/lib/structures/misc/SourceParser.test.ts
 create mode 100644 tests/lib/structures/misc/TypeParameterParser.test.ts
 create mode 100644 tests/lib/structures/type-parsers/IntrinsicTypeParser.test.ts

diff --git a/README.md b/README.md
index 493af167..aa8a92e8 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@
 
 [![GitHub](https://img.shields.io/github/license/RealShadowNova/typedoc-json-parser)](https://github.com/RealShadowNova/typedoc-json-parserblob/main/LICENSE.md)
 [![npm](https://img.shields.io/npm/v/typedoc-json-parser?color=crimson&logo=npm&style=flat-square)](https://www.npmjs.com/package/typedoc-json-parser)
+[![codecov](https://codecov.io/gh/RealShadowNova/typedoc-json-parser/branch/main/graph/badge.svg?token=JnJcjxqT3k)](https://codecov.io/gh/RealShadowNova/typedoc-json-parser)
 
 [![Support Server](https://discord.com/api/guilds/554742955898961930/embed.png?style=banner2)](https://discord.gg/fERY6AenEv)
 
diff --git a/tests/lib/structures/FunctionParser.test.ts b/tests/lib/structures/FunctionParser.test.ts
new file mode 100644
index 00000000..3b544845
--- /dev/null
+++ b/tests/lib/structures/FunctionParser.test.ts
@@ -0,0 +1,13 @@
+import { FunctionParser } from '../../../src/';
+
+describe('FunctionParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof FunctionParser THEN returns function', () => {
+      expect(typeof FunctionParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof FunctionParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/NamespaceParser.test.ts b/tests/lib/structures/NamespaceParser.test.ts
new file mode 100644
index 00000000..726c684c
--- /dev/null
+++ b/tests/lib/structures/NamespaceParser.test.ts
@@ -0,0 +1,13 @@
+import { NamespaceParser } from '../../../src/';
+
+describe('NamespaceParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof NamespaceParser THEN returns function', () => {
+      expect(typeof NamespaceParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof NamespaceParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/TypeAliasParser.test.ts b/tests/lib/structures/TypeAliasParser.test.ts
new file mode 100644
index 00000000..6cffa1e9
--- /dev/null
+++ b/tests/lib/structures/TypeAliasParser.test.ts
@@ -0,0 +1,13 @@
+import { TypeAliasParser } from '../../../src/';
+
+describe('TypeAliasParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof TypeAliasParser THEN returns function', () => {
+      expect(typeof TypeAliasParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof TypeAliasParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/VariableParser.test.ts b/tests/lib/structures/VariableParser.test.ts
new file mode 100644
index 00000000..27fbf44f
--- /dev/null
+++ b/tests/lib/structures/VariableParser.test.ts
@@ -0,0 +1,13 @@
+import { VariableParser } from '../../../src/';
+
+describe('VariableParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof VariableParser THEN returns function', () => {
+      expect(typeof VariableParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof VariableParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/class-parser/ClassConstructorParser.test.ts b/tests/lib/structures/class-parser/ClassConstructorParser.test.ts
new file mode 100644
index 00000000..a3b7f079
--- /dev/null
+++ b/tests/lib/structures/class-parser/ClassConstructorParser.test.ts
@@ -0,0 +1,197 @@
+import type { JSONOutput } from 'typedoc';
+import { ClassConstructorParser, ClassParser } from '../../../../src/';
+import { commentJson, commentReflection } from '../misc/CommentParser.test';
+import { parameterJson } from '../misc/ParameterParser.test';
+import { signatureReflection } from '../misc/SignatureParser.test';
+import { sourceJson, sourceReflection } from '../misc/SourceParser.test';
+
+export const classConstructorReflection: JSONOutput.DeclarationReflection = {
+  id: 1,
+  name: 'constructor',
+  kind: 512,
+  kindString: 'Constructor',
+  flags: { isPublic: true },
+  comment: commentReflection,
+  sources: [sourceReflection],
+  signatures: [{ ...signatureReflection, kind: 16384 }]
+};
+
+export const classConstructorJson: ClassConstructorParser.Json = {
+  id: 1,
+  name: 'constructor',
+  source: sourceJson,
+  comment: commentJson,
+  parentId: 2,
+  accessibility: ClassParser.Accessibility.Public,
+  parameters: [parameterJson]
+};
+
+describe('ClassConstructorParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof ClassConstructorParser THEN returns function', () => {
+      expect(typeof ClassConstructorParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof ClassConstructorParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN classConstructorReflection THEN returns classConstructorJson', () => {
+        expect(ClassConstructorParser.generateFromTypeDoc(classConstructorReflection, classConstructorJson.parentId)).toEqual(classConstructorJson);
+      });
+
+      const parser = ClassConstructorParser.generateFromTypeDoc(classConstructorReflection, classConstructorJson.parentId);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ClassConstructorParser#id THEN returns id', () => {
+            expect(parser.id).toBe(classConstructorJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ClassConstructorParser#name THEN returns name', () => {
+            expect(parser.name).toBe(classConstructorJson.name);
+          });
+        });
+
+        describe('source', () => {
+          test('GIVEN ClassConstructorParser#source THEN returns source', () => {
+            expect(parser.source).toEqual(classConstructorJson.source);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN ClassConstructorParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(classConstructorJson.comment);
+          });
+        });
+
+        describe('parentId', () => {
+          test('GIVEN ClassConstructorParser#parentId THEN returns parentId', () => {
+            expect(parser.parentId).toBe(classConstructorJson.parentId);
+          });
+        });
+
+        describe('accessibility', () => {
+          test('GIVEN ClassConstructorParser#accessibility THEN returns accessibility', () => {
+            expect(parser.accessibility).toBe(classConstructorJson.accessibility);
+          });
+        });
+
+        describe('parameters', () => {
+          test('GIVEN ClassConstructorParser#parameters THEN returns parameters', () => {
+            expect(parser.parameters).toEqual(classConstructorJson.parameters);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('isPublic', () => {
+          test('GIVEN ClassConstructorParser#isPublic THEN returns true', () => {
+            expect(parser.isPublic()).toBe(true);
+          });
+        });
+
+        describe('isProtected', () => {
+          test('GIVEN ClassConstructorParser#isProtected THEN returns false', () => {
+            expect(parser.isProtected()).toBe(false);
+          });
+        });
+
+        describe('isPrivate', () => {
+          test('GIVEN ClassConstructorParser#isPrivate THEN returns false', () => {
+            expect(parser.isPrivate()).toBe(false);
+          });
+        });
+
+        describe('toJSON', () => {
+          test('GIVEN ClassConstructorParser#toJSON THEN returns classConstructorJson', () => {
+            expect(parser.toJSON()).toEqual(classConstructorJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN classConstructorJson THEN returns ClassConstructorParser', () => {
+        expect(ClassConstructorParser.generateFromJson(classConstructorJson)).toBeInstanceOf(ClassConstructorParser);
+      });
+
+      const parser = ClassConstructorParser.generateFromJson(classConstructorJson);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ClassConstructorParser#id THEN returns id', () => {
+            expect(parser.id).toBe(classConstructorJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ClassConstructorParser#name THEN returns name', () => {
+            expect(parser.name).toBe(classConstructorJson.name);
+          });
+        });
+
+        describe('source', () => {
+          test('GIVEN ClassConstructorParser#source THEN returns source', () => {
+            expect(parser.source).toEqual(classConstructorJson.source);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN ClassConstructorParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(classConstructorJson.comment);
+          });
+        });
+
+        describe('parentId', () => {
+          test('GIVEN ClassConstructorParser#parentId THEN returns parentId', () => {
+            expect(parser.parentId).toBe(classConstructorJson.parentId);
+          });
+        });
+
+        describe('accessibility', () => {
+          test('GIVEN ClassConstructorParser#accessibility THEN returns accessibility', () => {
+            expect(parser.accessibility).toBe(classConstructorJson.accessibility);
+          });
+        });
+
+        describe('parameters', () => {
+          test('GIVEN ClassConstructorParser#parameters THEN returns parameters', () => {
+            expect(parser.parameters).toEqual(classConstructorJson.parameters);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('isPublic', () => {
+          test('GIVEN ClassConstructorParser#isPublic THEN returns true', () => {
+            expect(parser.isPublic()).toBe(true);
+          });
+        });
+
+        describe('isProtected', () => {
+          test('GIVEN ClassConstructorParser#isProtected THEN returns false', () => {
+            expect(parser.isProtected()).toBe(false);
+          });
+        });
+
+        describe('isPrivate', () => {
+          test('GIVEN ClassConstructorParser#isPrivate THEN returns false', () => {
+            expect(parser.isPrivate()).toBe(false);
+          });
+        });
+
+        describe('toJSON', () => {
+          test('GIVEN ClassConstructorParser#toJSON THEN returns classConstructorJson', () => {
+            expect(parser.toJSON()).toEqual(classConstructorJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/class-parser/ClassMethodParser.test.ts b/tests/lib/structures/class-parser/ClassMethodParser.test.ts
new file mode 100644
index 00000000..73a3176e
--- /dev/null
+++ b/tests/lib/structures/class-parser/ClassMethodParser.test.ts
@@ -0,0 +1,207 @@
+import type { JSONOutput } from 'typedoc';
+import { ClassMethodParser, ClassParser } from '../../../../src/';
+import { signatureJson, signatureReflection } from '../misc/SignatureParser.test';
+import { sourceJson, sourceReflection } from '../misc/SourceParser.test';
+
+export const classMethodReflection: JSONOutput.DeclarationReflection = {
+  id: 1,
+  name: 'method',
+  kind: 2048,
+  kindString: 'Method',
+  flags: { isPublic: true },
+  sources: [sourceReflection],
+  signatures: [signatureReflection]
+};
+
+export const classMethodJson: ClassMethodParser.Json = {
+  id: 1,
+  name: 'method',
+  source: sourceJson,
+  parentId: 2,
+  accessibility: ClassParser.Accessibility.Public,
+  static: false,
+  abstract: false,
+  signatures: [signatureJson]
+};
+
+describe('ClassMethodParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof ClassMethodParser THEN returns function', () => {
+      expect(typeof ClassMethodParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof ClassMethodParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN classMethodReflection THEN returns ClassMethodParser', () => {
+        expect(ClassMethodParser.generateFromTypeDoc(classMethodReflection, classMethodJson.parentId)).toBeInstanceOf(ClassMethodParser);
+      });
+
+      const parser = ClassMethodParser.generateFromTypeDoc(classMethodReflection, classMethodJson.parentId);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ClassMethodParser#id THEN returns id', () => {
+            expect(parser.id).toBe(classMethodJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ClassMethodParser#name THEN returns name', () => {
+            expect(parser.name).toBe(classMethodJson.name);
+          });
+        });
+
+        describe('source', () => {
+          test('GIVEN ClassMethodParser#source THEN returns source', () => {
+            expect(parser.source).toEqual(classMethodJson.source);
+          });
+        });
+
+        describe('parentId', () => {
+          test('GIVEN ClassMethodParser#parentId THEN returns parentId', () => {
+            expect(parser.parentId).toBe(classMethodJson.parentId);
+          });
+        });
+
+        describe('accessibility', () => {
+          test('GIVEN ClassMethodParser#accessibility THEN returns accessibility', () => {
+            expect(parser.accessibility).toBe(classMethodJson.accessibility);
+          });
+        });
+
+        describe('static', () => {
+          test('GIVEN ClassMethodParser#static THEN returns static', () => {
+            expect(parser.static).toBe(classMethodJson.static);
+          });
+        });
+
+        describe('abstract', () => {
+          test('GIVEN ClassMethodParser#abstract THEN returns abstract', () => {
+            expect(parser.abstract).toBe(classMethodJson.abstract);
+          });
+        });
+
+        describe('signatures', () => {
+          test('GIVEN ClassMethodParser#signatures THEN returns signatures', () => {
+            expect(parser.signatures).toEqual(classMethodJson.signatures);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('isPublic', () => {
+          test('GIVEN ClassMethodParser#isPublic THEN returns true', () => {
+            expect(parser.isPublic()).toBe(true);
+          });
+        });
+
+        describe('isProtected', () => {
+          test('GIVEN ClassMethodParser#isProtected THEN returns false', () => {
+            expect(parser.isProtected()).toBe(false);
+          });
+        });
+
+        describe('isPrivate', () => {
+          test('GIVEN ClassMethodParser#isPrivate THEN returns false', () => {
+            expect(parser.isPrivate()).toBe(false);
+          });
+        });
+
+        describe('toJSON', () => {
+          test('GIVEN ClassMethodParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(classMethodJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN classMethodJson THEN returns ClassMethodParser', () => {
+        expect(ClassMethodParser.generateFromJson(classMethodJson)).toBeInstanceOf(ClassMethodParser);
+      });
+
+      const parser = ClassMethodParser.generateFromJson(classMethodJson);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ClassMethodParser#id THEN returns id', () => {
+            expect(parser.id).toBe(classMethodJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ClassMethodParser#name THEN returns name', () => {
+            expect(parser.name).toBe(classMethodJson.name);
+          });
+        });
+
+        describe('source', () => {
+          test('GIVEN ClassMethodParser#source THEN returns source', () => {
+            expect(parser.source).toEqual(classMethodJson.source);
+          });
+        });
+
+        describe('parentId', () => {
+          test('GIVEN ClassMethodParser#parentId THEN returns parentId', () => {
+            expect(parser.parentId).toBe(classMethodJson.parentId);
+          });
+        });
+
+        describe('accessibility', () => {
+          test('GIVEN ClassMethodParser#accessibility THEN returns accessibility', () => {
+            expect(parser.accessibility).toBe(classMethodJson.accessibility);
+          });
+        });
+
+        describe('static', () => {
+          test('GIVEN ClassMethodParser#static THEN returns static', () => {
+            expect(parser.static).toBe(classMethodJson.static);
+          });
+        });
+
+        describe('abstract', () => {
+          test('GIVEN ClassMethodParser#abstract THEN returns abstract', () => {
+            expect(parser.abstract).toBe(classMethodJson.abstract);
+          });
+        });
+
+        describe('signatures', () => {
+          test('GIVEN ClassMethodParser#signatures THEN returns signatures', () => {
+            expect(parser.signatures).toEqual(classMethodJson.signatures);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('isPublic', () => {
+          test('GIVEN ClassMethodParser#isPublic THEN returns true', () => {
+            expect(parser.isPublic()).toBe(true);
+          });
+        });
+
+        describe('isProtected', () => {
+          test('GIVEN ClassMethodParser#isProtected THEN returns false', () => {
+            expect(parser.isProtected()).toBe(false);
+          });
+        });
+
+        describe('isPrivate', () => {
+          test('GIVEN ClassMethodParser#isPrivate THEN returns false', () => {
+            expect(parser.isPrivate()).toBe(false);
+          });
+        });
+
+        describe('toJSON', () => {
+          test('GIVEN ClassMethodParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(classMethodJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/class-parser/ClassParser.test.ts b/tests/lib/structures/class-parser/ClassParser.test.ts
new file mode 100644
index 00000000..b7031636
--- /dev/null
+++ b/tests/lib/structures/class-parser/ClassParser.test.ts
@@ -0,0 +1,13 @@
+import { ClassParser } from '../../../../src/';
+
+describe('ClassParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof ClassParser THEN returns function', () => {
+      expect(typeof ClassParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof ClassParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/class-parser/ClassPropertyParser.test.ts b/tests/lib/structures/class-parser/ClassPropertyParser.test.ts
new file mode 100644
index 00000000..f0750988
--- /dev/null
+++ b/tests/lib/structures/class-parser/ClassPropertyParser.test.ts
@@ -0,0 +1,13 @@
+import { ClassPropertyParser } from '../../../../src/';
+
+describe('ClassPropertyParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof ClassPropertyParser THEN returns function', () => {
+      expect(typeof ClassPropertyParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof ClassPropertyParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/enum-parser/EnumMember.test.ts b/tests/lib/structures/enum-parser/EnumMember.test.ts
new file mode 100644
index 00000000..d3d4688b
--- /dev/null
+++ b/tests/lib/structures/enum-parser/EnumMember.test.ts
@@ -0,0 +1,13 @@
+import { EnumMemberParser } from '../../../../src/';
+
+describe('EnumMemberParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof EnumMemberParser THEN returns function', () => {
+      expect(typeof EnumMemberParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof EnumMemberParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/enum-parser/EnumParser.test.ts b/tests/lib/structures/enum-parser/EnumParser.test.ts
new file mode 100644
index 00000000..69b9b48c
--- /dev/null
+++ b/tests/lib/structures/enum-parser/EnumParser.test.ts
@@ -0,0 +1,13 @@
+import { EnumParser } from '../../../../src/';
+
+describe('EnumParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof EnumParser THEN returns function', () => {
+      expect(typeof EnumParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof EnumParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/interface-parser/InterfaceMethodParser.test.ts b/tests/lib/structures/interface-parser/InterfaceMethodParser.test.ts
new file mode 100644
index 00000000..b8ad500d
--- /dev/null
+++ b/tests/lib/structures/interface-parser/InterfaceMethodParser.test.ts
@@ -0,0 +1,13 @@
+import { InterfaceMethodParser } from '../../../../src/';
+
+describe('InterfaceMethodParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof InterfaceMethodParser THEN returns function', () => {
+      expect(typeof InterfaceMethodParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof InterfaceMethodParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/interface-parser/InterfaceParser.test.ts b/tests/lib/structures/interface-parser/InterfaceParser.test.ts
new file mode 100644
index 00000000..f9e9915f
--- /dev/null
+++ b/tests/lib/structures/interface-parser/InterfaceParser.test.ts
@@ -0,0 +1,13 @@
+import { InterfaceParser } from '../../../../src/';
+
+describe('InterfaceParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof InterfaceParser THEN returns function', () => {
+      expect(typeof InterfaceParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof InterfaceParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/interface-parser/InterfacePropertyParser.test.ts b/tests/lib/structures/interface-parser/InterfacePropertyParser.test.ts
new file mode 100644
index 00000000..0a3efbde
--- /dev/null
+++ b/tests/lib/structures/interface-parser/InterfacePropertyParser.test.ts
@@ -0,0 +1,13 @@
+import { InterfacePropertyParser } from '../../../../src/';
+
+describe('InterfacePropertyParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof InterfacePropertyParser THEN returns function', () => {
+      expect(typeof InterfacePropertyParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof InterfacePropertyParser.prototype).toBe('object');
+    });
+  });
+});
diff --git a/tests/lib/structures/misc/CommentParser.test.ts b/tests/lib/structures/misc/CommentParser.test.ts
new file mode 100644
index 00000000..ce122f77
--- /dev/null
+++ b/tests/lib/structures/misc/CommentParser.test.ts
@@ -0,0 +1,140 @@
+import type { JSONOutput } from 'typedoc';
+import { CommentParser } from '../../../../src/';
+
+export const commentReflection: JSONOutput.Comment = {
+  summary: [{ kind: 'text', text: 'This is a description.' }],
+  blockTags: [{ tag: '@tag', content: [{ kind: 'text', text: 'This is a tag.' }] }],
+  modifierTags: ['modifier']
+};
+
+export const commentJson: CommentParser.Json = {
+  description: 'This is a description.',
+  blockTags: [{ name: 'tag', text: 'This is a tag.' }],
+  modifierTags: ['modifier']
+};
+
+describe('CommentParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof CommentParser THEN returns function', () => {
+      expect(typeof CommentParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof CommentParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN comment THEN returns CommentParser', () => {
+        expect(CommentParser.generateFromTypeDoc(commentReflection)).toBeInstanceOf(CommentParser);
+      });
+
+      const parser = CommentParser.generateFromJson(commentJson);
+
+      describe('properties', () => {
+        describe('description', () => {
+          test('GIVEN CommentParser#description THEN returns description', () => {
+            expect(parser.description).toBe(commentJson.description);
+          });
+        });
+
+        describe('blockTags', () => {
+          test('GIVEN CommentParser#blockTags THEN returns blockTags', () => {
+            expect(parser.blockTags).toBe(commentJson.blockTags);
+          });
+        });
+
+        describe('modifierTags', () => {
+          test('GIVEN CommentParser#modifierTags THEN returns modifierTags', () => {
+            expect(parser.modifierTags).toBe(commentJson.modifierTags);
+          });
+        });
+      });
+
+      describe('accessors', () => {
+        describe('see', () => {
+          test('GIVEN CommentParser#see THEN returns empty array', () => {
+            expect(parser.see).toEqual([]);
+          });
+        });
+
+        describe('example', () => {
+          test('GIVEN CommentParser#example THEN returns empty array', () => {
+            expect(parser.example).toEqual([]);
+          });
+        });
+
+        describe('deprecated', () => {
+          test('GIVEN CommentParser#deprecated THEN returns null', () => {
+            expect(parser.deprecated).toBe(false);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN CommentParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(commentJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN valid json THEN returns instance', () => {
+        expect(CommentParser.generateFromJson(commentJson)).toBeInstanceOf(CommentParser);
+      });
+
+      const parser = CommentParser.generateFromJson(commentJson);
+
+      describe('properties', () => {
+        describe('description', () => {
+          test('GIVEN CommentParser#description THEN returns description', () => {
+            expect(parser.description).toBe(commentJson.description);
+          });
+        });
+
+        describe('blockTags', () => {
+          test('GIVEN CommentParser#blockTags THEN returns blockTags', () => {
+            expect(parser.blockTags).toBe(commentJson.blockTags);
+          });
+        });
+
+        describe('modifierTags', () => {
+          test('GIVEN CommentParser#modifierTags THEN returns modifierTags', () => {
+            expect(parser.modifierTags).toBe(commentJson.modifierTags);
+          });
+        });
+      });
+
+      describe('accessors', () => {
+        describe('see', () => {
+          test('GIVEN CommentParser#see THEN returns empty array', () => {
+            expect(parser.see).toEqual([]);
+          });
+        });
+
+        describe('example', () => {
+          test('GIVEN CommentParser#example THEN returns empty array', () => {
+            expect(parser.example).toEqual([]);
+          });
+        });
+
+        describe('deprecated', () => {
+          test('GIVEN CommentParser#deprecated THEN returns null', () => {
+            expect(parser.deprecated).toBe(false);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN CommentParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(commentJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/misc/ParameterParser.test.ts b/tests/lib/structures/misc/ParameterParser.test.ts
new file mode 100644
index 00000000..729f1276
--- /dev/null
+++ b/tests/lib/structures/misc/ParameterParser.test.ts
@@ -0,0 +1,119 @@
+import type { JSONOutput } from 'typedoc';
+import { ParameterParser } from '../../../../src/';
+import { intrinsicTypeJson, intrinsicTypeReflection } from '../type-parsers/IntrinsicTypeParser.test';
+import { commentJson, commentReflection } from './CommentParser.test';
+
+export const parameterReflection: JSONOutput.DeclarationReflection = {
+  id: 1,
+  name: 'parameter',
+  kind: 32768,
+  kindString: 'Parameter',
+  flags: {},
+  comment: commentReflection,
+  type: intrinsicTypeReflection
+};
+
+export const parameterJson: ParameterParser.Json = {
+  id: 1,
+  name: 'parameter',
+  comment: commentJson,
+  type: intrinsicTypeJson
+};
+
+describe('ParameterParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof ParameterParser THEN returns function', () => {
+      expect(typeof ParameterParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof ParameterParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN parameterReflection THEN returns parameterJson', () => {
+        expect(ParameterParser.generateFromTypeDoc(parameterReflection)).toEqual(parameterJson);
+      });
+
+      const parser = ParameterParser.generateFromTypeDoc(parameterReflection);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ParameterParser#id THEN returns id', () => {
+            expect(parser.id).toBe(parameterJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ParameterParser#name THEN returns name', () => {
+            expect(parser.name).toBe(parameterJson.name);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN ParameterParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(parameterJson.comment);
+          });
+        });
+
+        describe('type', () => {
+          test('GIVEN ParameterParser#type THEN returns type', () => {
+            expect(parser.type).toEqual(parameterJson.type);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN ParameterParser#toJSON THEN returns parameterJson', () => {
+            expect(parser.toJSON()).toEqual(parameterJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN json THEN returns ParameterParser', () => {
+        expect(ParameterParser.generateFromJson(parameterJson)).toBeInstanceOf(ParameterParser);
+      });
+
+      const parser = ParameterParser.generateFromJson(parameterJson);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN ParameterParser#id THEN returns id', () => {
+            expect(parser.id).toBe(parameterJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN ParameterParser#name THEN returns name', () => {
+            expect(parser.name).toBe(parameterJson.name);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN ParameterParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(parameterJson.comment);
+          });
+        });
+
+        describe('type', () => {
+          test('GIVEN ParameterParser#type THEN returns type', () => {
+            expect(parser.type).toEqual(parameterJson.type);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN ParameterParser#toJSON THEN returns parameterJson', () => {
+            expect(parser.toJSON()).toEqual(parameterJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/misc/SignatureParser.test.ts b/tests/lib/structures/misc/SignatureParser.test.ts
new file mode 100644
index 00000000..95ec717e
--- /dev/null
+++ b/tests/lib/structures/misc/SignatureParser.test.ts
@@ -0,0 +1,149 @@
+import type { JSONOutput } from 'typedoc';
+import { SignatureParser } from '../../../../src/';
+import { intrinsicTypeJson, intrinsicTypeReflection } from '../type-parsers/IntrinsicTypeParser.test';
+import { commentJson, commentReflection } from './CommentParser.test';
+import { parameterJson, parameterReflection } from './ParameterParser.test';
+import { typeParameterJson, typeParameterReflection } from './TypeParameterParser.test';
+
+export const signatureReflection: JSONOutput.SignatureReflection = {
+  id: 1,
+  name: 'signature',
+  kind: 4096,
+  kindString: 'Call Signature',
+  flags: {},
+  comment: commentReflection,
+  typeParameter: [typeParameterReflection],
+  parameters: [parameterReflection],
+  type: intrinsicTypeReflection
+};
+
+export const signatureJson: SignatureParser.Json = {
+  id: 1,
+  name: 'signature',
+  comment: commentJson,
+  typeParameters: [typeParameterJson],
+  parameters: [parameterJson],
+  returnType: intrinsicTypeJson
+};
+
+describe('SignatureParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof SignatureParser THEN returns function', () => {
+      expect(typeof SignatureParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof SignatureParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN reflection THEN returns SignatureParser', () => {
+        expect(SignatureParser.generateFromTypeDoc(signatureReflection)).toBeInstanceOf(SignatureParser);
+      });
+
+      const parser = SignatureParser.generateFromTypeDoc(signatureReflection);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN SignatureParser#id THEN returns id', () => {
+            expect(parser.id).toBe(signatureJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN SignatureParser#name THEN returns name', () => {
+            expect(parser.name).toBe(signatureJson.name);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN SignatureParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(signatureJson.comment);
+          });
+        });
+
+        describe('typeParameters', () => {
+          test('GIVEN SignatureParser#typeParameters THEN returns typeParameters', () => {
+            expect(parser.typeParameters).toEqual(signatureJson.typeParameters);
+          });
+        });
+
+        describe('parameters', () => {
+          test('GIVEN SignatureParser#parameters THEN returns parameters', () => {
+            expect(parser.parameters).toEqual(signatureJson.parameters);
+          });
+        });
+
+        describe('returnType', () => {
+          test('GIVEN SignatureParser#returnType THEN returns returnType', () => {
+            expect(parser.returnType).toEqual(signatureJson.returnType);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN SignatureParser#toJSON THEN returns signatureJson', () => {
+            expect(parser.toJSON()).toEqual(signatureJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN json THEN returns SignatureParser', () => {
+        expect(SignatureParser.generateFromJson(signatureJson)).toBeInstanceOf(SignatureParser);
+      });
+
+      const parser = SignatureParser.generateFromJson(signatureJson);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN SignatureParser#id THEN returns id', () => {
+            expect(parser.id).toBe(signatureJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN SignatureParser#name THEN returns name', () => {
+            expect(parser.name).toBe(signatureJson.name);
+          });
+        });
+
+        describe('comment', () => {
+          test('GIVEN SignatureParser#comment THEN returns comment', () => {
+            expect(parser.comment).toEqual(signatureJson.comment);
+          });
+        });
+
+        describe('typeParameters', () => {
+          test('GIVEN SignatureParser#typeParameters THEN returns typeParameters', () => {
+            expect(parser.typeParameters).toEqual(signatureJson.typeParameters);
+          });
+        });
+
+        describe('parameters', () => {
+          test('GIVEN SignatureParser#parameters THEN returns parameters', () => {
+            expect(parser.parameters).toEqual(signatureJson.parameters);
+          });
+        });
+
+        describe('returnType', () => {
+          test('GIVEN SignatureParser#returnType THEN returns returnType', () => {
+            expect(parser.returnType).toEqual(signatureJson.returnType);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN SignatureParser#toJSON THEN returns signatureReflection', () => {
+            expect(parser.toJSON()).toEqual(signatureJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/misc/SourceParser.test.ts b/tests/lib/structures/misc/SourceParser.test.ts
new file mode 100644
index 00000000..1abfb278
--- /dev/null
+++ b/tests/lib/structures/misc/SourceParser.test.ts
@@ -0,0 +1,114 @@
+import type { JSONOutput } from 'typedoc';
+import { SourceParser } from '../../../../src/';
+
+export const sourceReflection: JSONOutput.SourceReference = {
+  fileName: 'path/to/FileName.ts',
+  line: 1,
+  character: 1,
+  url: 'https://example.com'
+};
+
+export const sourceJson: SourceParser.Json = {
+  file: 'FileName.ts',
+  path: 'path/to',
+  line: 1,
+  url: 'https://example.com'
+};
+
+describe('SourceParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof SourceParser THEN returns function', () => {
+      expect(typeof SourceParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof SourceParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN reflection THEN returns SourceParser', () => {
+        expect(SourceParser.generateFromTypeDoc(sourceReflection)).toBeInstanceOf(SourceParser);
+      });
+
+      const parser = SourceParser.generateFromTypeDoc(sourceReflection);
+
+      describe('properties', () => {
+        describe('line', () => {
+          test('GIVEN SourceParser#line THEN returns line', () => {
+            expect(parser.line).toBe(sourceJson.line);
+          });
+        });
+
+        describe('file', () => {
+          test('GIVEN SourceParser#file THEN returns file', () => {
+            expect(parser.file).toBe(sourceJson.file);
+          });
+        });
+
+        describe('path', () => {
+          test('GIVEN SourceParser#path THEN returns path', () => {
+            expect(parser.path).toBe(sourceJson.path);
+          });
+        });
+
+        describe('url', () => {
+          test('GIVEN SourceParser#url THEN returns url', () => {
+            expect(parser.url).toBe(sourceJson.url);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN SourceParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(sourceJson);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN json THEN returns SourceParser', () => {
+        expect(SourceParser.generateFromJson(sourceJson)).toBeInstanceOf(SourceParser);
+      });
+
+      const parser = SourceParser.generateFromJson(sourceJson);
+
+      describe('properties', () => {
+        describe('line', () => {
+          test('GIVEN SourceParser#line THEN returns line', () => {
+            expect(parser.line).toBe(sourceJson.line);
+          });
+        });
+
+        describe('file', () => {
+          test('GIVEN SourceParser#file THEN returns file', () => {
+            expect(parser.file).toBe(sourceJson.file);
+          });
+        });
+
+        describe('path', () => {
+          test('GIVEN SourceParser#path THEN returns path', () => {
+            expect(parser.path).toBe(sourceJson.path);
+          });
+        });
+
+        describe('url', () => {
+          test('GIVEN SourceParser#url THEN returns url', () => {
+            expect(parser.url).toBe(sourceJson.url);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN SourceParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(sourceJson);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/misc/TypeParameterParser.test.ts b/tests/lib/structures/misc/TypeParameterParser.test.ts
new file mode 100644
index 00000000..cd29a33c
--- /dev/null
+++ b/tests/lib/structures/misc/TypeParameterParser.test.ts
@@ -0,0 +1,114 @@
+import type { JSONOutput } from 'typedoc';
+import { TypeParameterParser } from '../../../../src/';
+import { intrinsicTypeJson, intrinsicTypeReflection } from '../type-parsers/IntrinsicTypeParser.test';
+
+export const typeParameterReflection: JSONOutput.TypeParameterReflection = {
+  id: 1,
+  name: 'T',
+  kind: 131072,
+  kindString: 'Type Parameter',
+  flags: {},
+  type: intrinsicTypeReflection,
+  default: intrinsicTypeReflection
+};
+
+export const typeParameterJson: TypeParameterParser.Json = {
+  id: 1,
+  name: 'T',
+  constraint: intrinsicTypeJson,
+  default: intrinsicTypeJson
+};
+
+describe('TypeParameterParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof TypeParameterParser THEN returns function', () => {
+      expect(typeof TypeParameterParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof TypeParameterParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN reflection THEN returns TypeParameterParser', () => {
+        expect(TypeParameterParser.generateFromTypeDoc(typeParameterReflection)).toBeInstanceOf(TypeParameterParser);
+      });
+
+      const parser = TypeParameterParser.generateFromTypeDoc(typeParameterReflection);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN TypeParameterParser#id THEN returns id', () => {
+            expect(parser.id).toBe(typeParameterJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN TypeParameterParser#name THEN returns name', () => {
+            expect(parser.name).toBe(typeParameterJson.name);
+          });
+        });
+
+        describe('constraint', () => {
+          test('GIVEN TypeParameterParser#constraint THEN returns constraint', () => {
+            expect(parser.constraint).toEqual(typeParameterJson.constraint);
+          });
+        });
+
+        describe('default', () => {
+          test('GIVEN TypeParameterParser#default THEN returns default', () => {
+            expect(parser.default).toEqual(typeParameterJson.default);
+          });
+        });
+      });
+
+      describe('toJSON', () => {
+        test('GIVEN TypeParameterParser#toJSON THEN returns JSON', () => {
+          expect(parser.toJSON()).toEqual(typeParameterJson);
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN json THEN returns TypeParameterParser', () => {
+        expect(TypeParameterParser.generateFromJson(typeParameterJson)).toBeInstanceOf(TypeParameterParser);
+      });
+
+      const parser = TypeParameterParser.generateFromJson(typeParameterJson);
+
+      describe('properties', () => {
+        describe('id', () => {
+          test('GIVEN TypeParameterParser#id THEN returns id', () => {
+            expect(parser.id).toBe(typeParameterJson.id);
+          });
+        });
+
+        describe('name', () => {
+          test('GIVEN TypeParameterParser#name THEN returns name', () => {
+            expect(parser.name).toBe(typeParameterJson.name);
+          });
+        });
+
+        describe('constraint', () => {
+          test('GIVEN TypeParameterParser#constraint THEN returns constraint', () => {
+            expect(parser.constraint).toEqual(typeParameterJson.constraint);
+          });
+        });
+
+        describe('default', () => {
+          test('GIVEN TypeParameterParser#default THEN returns default', () => {
+            expect(parser.default).toEqual(typeParameterJson.default);
+          });
+        });
+      });
+
+      describe('toJSON', () => {
+        test('GIVEN TypeParameterParser#toJSON THEN returns JSON', () => {
+          expect(parser.toJSON()).toEqual(typeParameterJson);
+        });
+      });
+    });
+  });
+});
diff --git a/tests/lib/structures/type-parsers/IntrinsicTypeParser.test.ts b/tests/lib/structures/type-parsers/IntrinsicTypeParser.test.ts
new file mode 100644
index 00000000..f63ce761
--- /dev/null
+++ b/tests/lib/structures/type-parsers/IntrinsicTypeParser.test.ts
@@ -0,0 +1,86 @@
+import type { JSONOutput } from 'typedoc';
+import { IntrinsicTypeParser, TypeParser } from '../../../../src';
+
+export const intrinsicTypeReflection: JSONOutput.IntrinsicType = {
+  type: 'intrinsic',
+
+  name: 'string'
+};
+
+export const intrinsicTypeJson: IntrinsicTypeParser.Json = {
+  kind: TypeParser.Kind.Intrinsic,
+
+  type: 'string'
+};
+
+describe('IntrinsicTypeParser', () => {
+  describe('is a class', () => {
+    test('GIVEN typeof IntrinsicTypeParser THEN returns function', () => {
+      expect(typeof IntrinsicTypeParser).toBe('function');
+    });
+
+    test('GIVEN typeof ...prototype THEN returns object', () => {
+      expect(typeof IntrinsicTypeParser.prototype).toBe('object');
+    });
+  });
+
+  describe('can create instance', () => {
+    describe('generateFromTypeDoc', () => {
+      test('GIVEN reflection THEN returns IntrinsicTypeParser', () => {
+        expect(TypeParser.generateFromTypeDoc(intrinsicTypeReflection)).toBeInstanceOf(IntrinsicTypeParser);
+      });
+
+      const parser = TypeParser.generateFromTypeDoc(intrinsicTypeReflection) as IntrinsicTypeParser;
+
+      describe('properties', () => {
+        describe('kind', () => {
+          test('GIVEN IntrinsicTypeParser#kind THEN returns kind', () => {
+            expect(parser.kind).toBe(intrinsicTypeJson.kind);
+          });
+        });
+
+        describe('type', () => {
+          test('GIVEN IntrinsicTypeParser#type THEN returns type', () => {
+            expect(parser.type).toBe(intrinsicTypeJson.type);
+          });
+        });
+      });
+    });
+
+    describe('generateFromJson', () => {
+      test('GIVEN json THEN returns IntrinsicTypeParser', () => {
+        expect(TypeParser.generateFromJson(intrinsicTypeJson)).toBeInstanceOf(IntrinsicTypeParser);
+      });
+
+      const parser = TypeParser.generateFromJson(intrinsicTypeJson) as IntrinsicTypeParser;
+
+      describe('properties', () => {
+        describe('kind', () => {
+          test('GIVEN IntrinsicTypeParser#kind THEN returns kind', () => {
+            expect(parser.kind).toBe(intrinsicTypeJson.kind);
+          });
+        });
+
+        describe('type', () => {
+          test('GIVEN IntrinsicTypeParser#type THEN returns type', () => {
+            expect(parser.type).toBe(intrinsicTypeJson.type);
+          });
+        });
+      });
+
+      describe('methods', () => {
+        describe('toJSON', () => {
+          test('GIVEN IntrinsicTypeParser#toJSON THEN returns json', () => {
+            expect(parser.toJSON()).toEqual(intrinsicTypeJson);
+          });
+        });
+
+        describe('toString', () => {
+          test('GIVEN IntrinsicTypeParser#toString THEN returns string', () => {
+            expect(parser.toString()).toBe('string');
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/vitest.config.ts b/vitest.config.ts
index 04ff81fd..bf15df5a 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -4,6 +4,7 @@ export default defineConfig({
   test: {
     globals: true,
     coverage: {
+      enabled: true,
       reporter: ['text', 'lcov', 'clover'],
       exclude: ['**/node_modules/**', '**/dist/**', '**/tests/**']
     }

From d4ed01adc5ac52a552309bf433d13d9825476dbe Mon Sep 17 00:00:00 2001
From: Hezekiah Hendry <hezekiah.hendry@gmail.com>
Date: Sat, 17 Jun 2023 02:57:32 -0400
Subject: [PATCH 2/2] test: resolve errors

---
 .../class-parser/ClassConstructorParser.test.ts     |  2 +-
 .../class-parser/ClassMethodParser.test.ts          |  2 +-
 tests/lib/structures/misc/ParameterParser.test.ts   | 13 +++++++++----
 tests/lib/structures/misc/SignatureParser.test.ts   |  2 +-
 .../lib/structures/misc/TypeParameterParser.test.ts |  2 +-
 5 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/tests/lib/structures/class-parser/ClassConstructorParser.test.ts b/tests/lib/structures/class-parser/ClassConstructorParser.test.ts
index a3b7f079..9bd8d2a0 100644
--- a/tests/lib/structures/class-parser/ClassConstructorParser.test.ts
+++ b/tests/lib/structures/class-parser/ClassConstructorParser.test.ts
@@ -9,7 +9,7 @@ export const classConstructorReflection: JSONOutput.DeclarationReflection = {
   id: 1,
   name: 'constructor',
   kind: 512,
-  kindString: 'Constructor',
+  variant: 'declaration',
   flags: { isPublic: true },
   comment: commentReflection,
   sources: [sourceReflection],
diff --git a/tests/lib/structures/class-parser/ClassMethodParser.test.ts b/tests/lib/structures/class-parser/ClassMethodParser.test.ts
index 73a3176e..aab1dd16 100644
--- a/tests/lib/structures/class-parser/ClassMethodParser.test.ts
+++ b/tests/lib/structures/class-parser/ClassMethodParser.test.ts
@@ -7,7 +7,7 @@ export const classMethodReflection: JSONOutput.DeclarationReflection = {
   id: 1,
   name: 'method',
   kind: 2048,
-  kindString: 'Method',
+  variant: 'declaration',
   flags: { isPublic: true },
   sources: [sourceReflection],
   signatures: [signatureReflection]
diff --git a/tests/lib/structures/misc/ParameterParser.test.ts b/tests/lib/structures/misc/ParameterParser.test.ts
index 729f1276..4800395e 100644
--- a/tests/lib/structures/misc/ParameterParser.test.ts
+++ b/tests/lib/structures/misc/ParameterParser.test.ts
@@ -3,12 +3,15 @@ import { ParameterParser } from '../../../../src/';
 import { intrinsicTypeJson, intrinsicTypeReflection } from '../type-parsers/IntrinsicTypeParser.test';
 import { commentJson, commentReflection } from './CommentParser.test';
 
-export const parameterReflection: JSONOutput.DeclarationReflection = {
+export const parameterReflection: JSONOutput.ParameterReflection = {
   id: 1,
   name: 'parameter',
   kind: 32768,
-  kindString: 'Parameter',
-  flags: {},
+  variant: 'param',
+  flags: {
+    isOptional: false,
+    isRest: false
+  },
   comment: commentReflection,
   type: intrinsicTypeReflection
 };
@@ -17,7 +20,9 @@ export const parameterJson: ParameterParser.Json = {
   id: 1,
   name: 'parameter',
   comment: commentJson,
-  type: intrinsicTypeJson
+  type: intrinsicTypeJson,
+  optional: false,
+  rest: false
 };
 
 describe('ParameterParser', () => {
diff --git a/tests/lib/structures/misc/SignatureParser.test.ts b/tests/lib/structures/misc/SignatureParser.test.ts
index 95ec717e..4067582b 100644
--- a/tests/lib/structures/misc/SignatureParser.test.ts
+++ b/tests/lib/structures/misc/SignatureParser.test.ts
@@ -9,7 +9,7 @@ export const signatureReflection: JSONOutput.SignatureReflection = {
   id: 1,
   name: 'signature',
   kind: 4096,
-  kindString: 'Call Signature',
+  variant: 'signature',
   flags: {},
   comment: commentReflection,
   typeParameter: [typeParameterReflection],
diff --git a/tests/lib/structures/misc/TypeParameterParser.test.ts b/tests/lib/structures/misc/TypeParameterParser.test.ts
index cd29a33c..7662a249 100644
--- a/tests/lib/structures/misc/TypeParameterParser.test.ts
+++ b/tests/lib/structures/misc/TypeParameterParser.test.ts
@@ -6,7 +6,7 @@ export const typeParameterReflection: JSONOutput.TypeParameterReflection = {
   id: 1,
   name: 'T',
   kind: 131072,
-  kindString: 'Type Parameter',
+  variant: 'typeParam',
   flags: {},
   type: intrinsicTypeReflection,
   default: intrinsicTypeReflection