什么是在上下文中更好地进行单元测试的静态类型 javascript 示例？答案

【问题标题】：What is an example of statically typed javascript in context to better unit testing?什么是在上下文中更好地进行单元测试的静态类型 javascript 示例？
【发布时间】：2015-01-13 06:29:47
【问题描述】：

我是测试新手，但最近我一直在尝试使用 angularJS 和 Jasmine。

随着 ES6 的出现，出现了新的框架/语言，例如：atScript 和 google angular-dart。两者现在都支持可选类型 javascript，并且他们声称它变得更容易测试？

问题： 1. 作为一个测试新手，谁能给我一个实际的例子/用例来说明静态类型的javascript如何更适合单元测试。此外还有一个香草 javascript 单元测试不足的例子？？

最后，如果这不是 stackoverflow 问题，我们可以将其移至适当的堆栈子域吗？

【问题讨论】：

我不知道更好的单元测试，但我可以看到它们是如何启用 less 单元测试的，因为运行时不允许很多需要做的事情今天明确测试。阅读为什么编译代码比解释代码“更好”的论点。静态类型还可以提供更好的 IDE 自动完成/建议功能，减少人为错误。
当今人工测试的一些问题，例如 typeof null==="object"、a+b/x 中的潜在连接以及 new String("a") vs " 上的 typeof a" 可能会消失，或者至少不是这样的“陷阱”。
Angular 的构建非常注重可测试性（Dart 和 JS），这与类型注释无关。除此之外，请参阅上面的@dandavis 评论。

标签： javascript angularjs unit-testing jasmine ecmascript-6

【解决方案1】：

基于类型的断言是可能的。例如：

is(value : Dynamic, type : Dynamic, ?msg : String , ?pos : PosInfos)

当 'value' 参数是传递的类型 'type' 时，成功断言。

raises(method:Void -> Void, ?type:Class<Dynamic>, ?msgNotThrown : String , ?msgWrongType : String, ?pos : PosInfos)

它用于测试在某些情况下必须做出反应并抛出错误的应用程序。此断言保证错误的类型正确（如果未指定，则为动态）。

这段代码：

enum Color { R, G, B }

function f1(x: Color | string) {
    if (typeof x === "number") {
        var y = x;
        var y: Color;
    }
    else {
        var z = x;
        var z: string;
    }
}

function f2(x: Color | string | string[]) {
    if (typeof x === "object") {
        var y = x;
        var y: string[];
    }
    if (typeof x === "number") {
        var z = x;
        var z: Color;
    }
    else {
        var w = x;
        var w: string | string[];
    }
    if (typeof x === "string") {
        var a = x;
        var a: string;
    }
    else {
        var b = x;
        var b: Color | string[];
    }
}

以下需要垫片：

枚举
类型提示 (x: Color)
联合类型 (|)

还有这段代码：

class A {
    propA: number;
}

class B {
    propB: number;
}

class C extends A {
    propC: number;
}

declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function retC(x): C; 

declare function funA<T>(p1: (p1) => T): T;
declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
declare function funC<T>(p1: (p1) => p1 is T): T;
declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;

let a: A;
let test1: boolean = funA(isB);

if (funB(retC, a)) {
    a.propC;
}
let test2: B = funC(isB);
if (funD(isC, a)) {
    a.propC;
}
let test3: B = funE(isB, 1);

以下需要垫片：

用户定义的类型保护 (p1 is B)
返回值的类型转换 (funA<T>(p1: (p1) => T): T)

参考文献

【讨论】：