tstyche 4.0.0-beta.0 → 4.0.0-beta.10

package/README.md

@@ -18,14 +18,15 @@ If you are used to test JavaScript, a simple type test file should look familiar
 ```ts
 import { expect, test } from "tstyche";
 
-function firstItem<T>(target: Array<T>): T | undefined {
-  return target[0];
+function isSameLength<T extends { length: number }>(a: T, b: T) {
+  return a.length === b.length;
 }
 
-test("firstItem", () => {
-  expect(firstItem(["a", "b", "c"])).type.toBe<string | undefined>();
+test("isSameLength", () => {
+  expect(isSameLength([1, 2], [1, 2, 3])).type.toBe<boolean>();
+  expect(isSameLength("one", "two")).type.toBe<boolean>();
 
-  expect(firstItem()).type.toRaiseError("Expected 1 argument");
+  expect(isSameLength).type.not.toBeCallableWith(1, 2);
 });
 ```
 
@@ -57,9 +58,12 @@ test("handles numbers", () => {
 Here is the list of all matchers:
 
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()` compare types or types of expression,
-- `.toAcceptProps()` checks JSX component props type,
+- `.toAcceptProps()` checks the type of JSX component props,
+- `.toBeApplicable` ensures that the decorator function can be applied,
+- `.toBeCallableWith()` checks whether a function is callable with the given arguments,
+- `.toBeConstructableWith()` checks whether a class is constructable with the given arguments,
 - `.toHaveProperty()` looks up keys on an object type,
-- `.toRaiseError()` captures the type error message or code.
+- `.toRaiseError()` captures the message or code of a type error.
 
 ## Runner
 

package/build/index.cjs

@@ -17,3 +17,4 @@ exports.it = noopChain;
 exports.omit = doNothing;
 exports.pick = doNothing;
 exports.test = noopChain;
+exports.when = noopChain;

package/build/index.d.cts

@@ -85,18 +85,22 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is identical to the target type.
+     * Checks if the source type is the same as the target type.
      */
     toBe: {
         /**
-         * Checks if the source type is identical to the target type.
+         * Checks if the source type is the same as the target type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is identical to type of the target expression.
+         * Checks if the source type is the same as type of the target expression.
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */
@@ -123,6 +127,14 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type is callable with the given arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
+    /**
+     * Checks if the source type is constructable with the given arguments.
+     */
+    toBeConstructableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */
@@ -257,5 +269,29 @@ declare const test: Test;
  * Defines a single test.
  */
 declare const it: Test;
+interface Actions {
+    /**
+     * Calls the given function with the provided arguments.
+     */
+    isCalledWith: (...args: Array<unknown>) => void;
+}
+interface When {
+    /**
+     * Creates a test plan.
+     *
+     * @template Target - The type upon which an action is performed.
+     */
+    <Target>(): Actions;
+    /**
+     * Creates a test plan.
+     *
+     * @param target - The expression upon which an action is performed.
+     */
+    (target: unknown): Actions;
+}
+/**
+ * Creates a test plan.
+ */
+declare const when: When;
 
-export { describe, expect, it, omit, pick, test };
+export { describe, expect, it, omit, pick, test, when };

package/build/index.d.ts

@@ -85,18 +85,22 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type is identical to the target type.
+     * Checks if the source type is the same as the target type.
      */
     toBe: {
         /**
-         * Checks if the source type is identical to the target type.
+         * Checks if the source type is the same as the target type.
          */
         <Target>(): void;
         /**
-         * Checks if the source type is identical to type of the target expression.
+         * Checks if the source type is the same as type of the target expression.
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */
@@ -123,6 +127,14 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type is callable with the given arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
+    /**
+     * Checks if the source type is constructable with the given arguments.
+     */
+    toBeConstructableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */
@@ -257,5 +269,29 @@ declare const test: Test;
  * Defines a single test.
  */
 declare const it: Test;
+interface Actions {
+    /**
+     * Calls the given function with the provided arguments.
+     */
+    isCalledWith: (...args: Array<unknown>) => void;
+}
+interface When {
+    /**
+     * Creates a test plan.
+     *
+     * @template Target - The type upon which an action is performed.
+     */
+    <Target>(): Actions;
+    /**
+     * Creates a test plan.
+     *
+     * @param target - The expression upon which an action is performed.
+     */
+    (target: unknown): Actions;
+}
+/**
+ * Creates a test plan.
+ */
+declare const when: When;
 
-export { describe, expect, it, omit, pick, test };
+export { describe, expect, it, omit, pick, test, when };

package/build/index.js

@@ -9,4 +9,4 @@ const noopChain = new Proxy(doNothing, {
     },
 });
 
-export { noopChain as describe, noopChain as expect, noopChain as it, doNothing as omit, doNothing as pick, noopChain as test };
+export { noopChain as describe, noopChain as expect, noopChain as it, doNothing as omit, doNothing as pick, noopChain as test, noopChain as when };

package/build/tstyche.d.ts

@@ -20,57 +20,11 @@ declare class Cli {
     run(commandLine: Array<string>, cancellationToken?: CancellationToken): Promise<void>;
 }
 
-declare enum DiagnosticCategory {
-    Error = "error",
-    Warning = "warning"
-}
-
-declare class SourceFile {
-    #private;
-    fileName: string;
-    text: string;
-    constructor(fileName: string, text: string);
-    getLineStarts(): Array<number>;
-    getLineAndCharacterOfPosition(position: number): {
-        line: number;
-        character: number;
-    };
-}
-
-declare class DiagnosticOrigin {
-    assertion: AssertionNode | undefined;
-    end: number;
-    sourceFile: SourceFile | ts.SourceFile;
-    start: number;
-    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
-    static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
-    static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
-}
-
-declare class Diagnostic {
-    category: DiagnosticCategory;
-    code: string | undefined;
-    origin: DiagnosticOrigin | undefined;
-    related: Array<Diagnostic> | undefined;
-    text: string | Array<string>;
-    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
-    add(options: {
-        code?: string | undefined;
-        related?: Array<Diagnostic> | undefined;
-    }): this;
-    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
-    static toMessageText(chain: ts.DiagnosticMessageChain): Array<string>;
-    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-}
-
-type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
-
 declare enum TestTreeNodeBrand {
     Describe = "describe",
     Test = "test",
-    Expect = "expect"
+    Expect = "expect",
+    When = "when"
 }
 
 declare enum TestTreeNodeFlags {
@@ -81,45 +35,43 @@ declare enum TestTreeNodeFlags {
     Todo = 8
 }
 
+declare class WhenNode extends TestTreeNode {
+    actionNode: ts.CallExpression;
+    actionNameNode: ts.PropertyAccessExpression;
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
+}
+
 declare class TestTreeNode {
-    #private;
     brand: TestTreeNodeBrand;
-    children: Array<TestTreeNode | AssertionNode>;
+    children: Array<TestTreeNode | AssertionNode | WhenNode>;
     diagnostics: Set<ts.Diagnostic>;
     flags: TestTreeNodeFlags;
     name: string;
     node: ts.CallExpression;
     parent: TestTree | TestTreeNode;
     constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags);
-    validate(): Array<Diagnostic>;
 }
 
 declare class TestTree {
-    children: Array<TestTreeNode | AssertionNode>;
+    children: Array<TestTreeNode | AssertionNode | WhenNode>;
     diagnostics: Set<ts.Diagnostic>;
     hasOnly: boolean;
     sourceFile: ts.SourceFile;
     constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
 }
 
-interface MatcherNode extends ts.CallExpression {
-    expression: ts.PropertyAccessExpression;
-}
 declare class AssertionNode extends TestTreeNode {
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
     isNot: boolean;
-    matcherName: ts.MemberName;
-    matcherNode: MatcherNode;
+    matcherNode: ts.CallExpression | ts.Decorator;
+    matcherNameNode: ts.PropertyAccessExpression;
     modifierNode: ts.PropertyAccessExpression;
     notNode: ts.PropertyAccessExpression | undefined;
     source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
-}
-
-declare class CollectService {
-    #private;
-    constructor(compiler: typeof ts);
-    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode> | undefined;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: ts.CallExpression | ts.Decorator, matcherNameNode: ts.PropertyAccessExpression, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
 }
 
 declare enum OptionBrand {
@@ -207,7 +159,7 @@ interface CommandLineOptions {
      */
     failFast?: boolean;
     /**
-     * Fetch specified versions of the 'typescript' package and exit.
+     * Fetch the specified versions of the 'typescript' package and exit.
      */
     fetch?: boolean;
     /**
@@ -297,6 +249,58 @@ declare class Config {
     static resolveConfigFilePath(filePath?: string): string;
 }
 
+declare enum DiagnosticCategory {
+    Error = "error",
+    Warning = "warning"
+}
+
+declare class SourceFile {
+    #private;
+    fileName: string;
+    text: string;
+    constructor(fileName: string, text: string);
+    getLineStarts(): Array<number>;
+    getLineAndCharacterOfPosition(position: number): {
+        line: number;
+        character: number;
+    };
+}
+
+declare class DiagnosticOrigin {
+    assertion: AssertionNode | undefined;
+    end: number;
+    sourceFile: SourceFile | ts.SourceFile;
+    start: number;
+    constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
+    static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
+    static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
+    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertion?: AssertionNode): DiagnosticOrigin;
+}
+
+declare class Diagnostic {
+    category: DiagnosticCategory;
+    code: string | undefined;
+    origin: DiagnosticOrigin | undefined;
+    related: Array<Diagnostic> | undefined;
+    text: string | Array<string>;
+    constructor(text: string | Array<string>, category: DiagnosticCategory, origin?: DiagnosticOrigin);
+    add(options: {
+        code?: string | undefined;
+        related?: Array<Diagnostic> | undefined;
+    }): this;
+    static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
+    static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
+}
+
+declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
+declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
+declare function getTextSpanEnd(span: ts.TextSpan): number;
+declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
+
+type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
+
 declare enum OptionGroup {
     CommandLine = 2,
     ConfigFile = 4,
@@ -330,6 +334,27 @@ declare class Options {
 
 declare const defaultOptions: Required<ConfigFileOptions>;
 
+declare class ProjectService {
+    #private;
+    constructor(compiler: typeof ts, resolvedConfig: ResolvedConfig);
+    closeFile(filePath: string): void;
+    getDefaultProject(filePath: string): ts.server.Project | undefined;
+    getLanguageService(filePath: string): ts.LanguageService | undefined;
+    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
+}
+
+declare class CollectService {
+    #private;
+    constructor(compiler: typeof ts, projectService: ProjectService, resolvedConfig: ResolvedConfig);
+    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+}
+
+declare function nodeBelongsToArgumentList(compiler: typeof ts, node: ts.Node): boolean;
+
+declare function argumentIsProvided<T>(argumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
+
+declare function argumentOrTypeArgumentIsProvided<T>(argumentNameText: string, typeArgumentNameText: string, node: T, enclosingNode: ts.Node, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): node is NonNullable<T>;
+
 interface EnvironmentOptions {
     /**
      * Is `true` if the process is running in continuous integration environment.
@@ -481,13 +506,12 @@ declare class TargetResult {
 declare class Result {
     expectCount: ResultCount;
     fileCount: ResultCount;
-    resolvedConfig: ResolvedConfig;
     results: Array<TargetResult>;
     targetCount: ResultCount;
     tasks: Array<Task>;
     testCount: ResultCount;
     timing: ResultTiming;
-    constructor(resolvedConfig: ResolvedConfig, tasks: Array<Task>);
+    constructor(tasks: Array<Task>);
 }
 
 interface EventHandler {
@@ -523,11 +547,13 @@ type Event = ["config:error", {
 }] | ["task:end", {
     result: TaskResult;
 }] | ["collect:start", {
-    testTree: TestTree;
+    tree: TestTree;
+}] | ["collect:error", {
+    diagnostics: Array<Diagnostic>;
 }] | ["collect:node", {
-    testNode: TestTreeNode | AssertionNode;
+    node: TestTreeNode | AssertionNode | WhenNode;
 }] | ["collect:end", {
-    testTree: TestTree;
+    tree: TestTree;
 }] | ["describe:start", {
     result: DescribeResult;
 }] | ["describe:end", {
@@ -574,29 +600,33 @@ declare class EventEmitter {
     removeReporters(): void;
 }
 
+declare class Reject {
+    #private;
+    constructor(compiler: typeof ts, typeChecker: ts.TypeChecker, resolvedConfig: ResolvedConfig);
+    argumentType(target: Array<[name: string, node: ts.Expression | ts.TypeNode | undefined]>, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): boolean;
+}
+
 interface MatchResult {
     explain: () => Array<Diagnostic>;
     isMatch: boolean;
 }
-type Relation = Map<string, unknown>;
 interface TypeChecker extends ts.TypeChecker {
     isApplicableIndexType: (source: ts.Type, target: ts.Type) => boolean;
-    isTypeRelatedTo: (source: ts.Type, target: ts.Type, relation: Relation) => boolean;
-    relation: {
-        assignable: Relation;
-        identity: Relation;
-    };
+    isTypeIdenticalTo: (source: ts.Type, target: ts.Type) => boolean;
 }
 
 declare class ExpectService {
     #private;
     private toAcceptProps;
     private toBe;
+    private toBeApplicable;
     private toBeAssignableTo;
     private toBeAssignableWith;
+    private toBeCallableWith;
+    private toBeConstructableWith;
     private toHaveProperty;
     private toRaiseError;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig: ResolvedConfig);
+    constructor(compiler: typeof ts, typeChecker: TypeChecker, reject: Reject);
     match(assertion: AssertionNode, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
 }
 
@@ -617,11 +647,6 @@ declare class ResultHandler implements EventHandler {
     on([event, payload]: Event): void;
 }
 
-declare class TestTreeHandler implements EventHandler {
-    testTree: TestTree | undefined;
-    on([event, payload]: Event): void;
-}
-
 type InputHandler = (chunk: string) => void;
 declare class InputService {
     #private;
@@ -712,13 +737,10 @@ declare class OutputService {
     static writeWarning(element: ScribblerJsx.Element | Array<ScribblerJsx.Element>): void;
 }
 
-declare function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }: {
+declare function summaryText({ duration, expectCount, fileCount, targetCount, testCount, }: {
     duration: number;
     expectCount: ResultCount;
     fileCount: ResultCount;
-    onlyMatch: string | undefined;
-    pathMatch: Array<string>;
-    skipMatch: string | undefined;
     targetCount: ResultCount;
     testCount: ResultCount;
 }): ScribblerJsx.Element;
@@ -767,15 +789,6 @@ declare class PluginService {
     static removeHandlers(): void;
 }
 
-declare class ProjectService {
-    #private;
-    constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
-    closeFile(filePath: string): void;
-    getDefaultProject(filePath: string): ts.server.Project | undefined;
-    getLanguageService(filePath: string): ts.LanguageService | undefined;
-    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
-}
-
 declare class Runner {
     #private;
     static version: string;
@@ -867,5 +880,11 @@ declare class WatchService {
     watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+declare class WhenService {
+    #private;
+    constructor(reject: Reject, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>);
+    action(when: WhenNode): void;
+}
+
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
 export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };