Jest: オブジェクト、配列、または文字列かどうかをテストします。

いいえ、ありません。 利用可能なすべてのマッチャーのリストは、 https ：//facebook.github.io/jest/docs/en/expect.htmlにあります

そのために、プレーンJavaScriptまたはlodashようなヘルパーライブラリを使用することもできます。

test('name', () => {
  // array
  expect(Array.isArray(['value'])).toBe(true);
  // string
  expect(typeof 'value').toBe('string');
  // object
  expect({value: 'value'}).toBeTruthy();
  expect(typeof {value: 'value'}).toBe('object');
})

マイナーポイント-これは約束の結果には役立ちません。

expect(somePromise).resolves.toBe(...)この時点では、型を確認する方法はありません。 内容が何であるかは気にしないが、それが文字列であるというだけの場合。 expects.stringContaining("")が回避策になることを望んでいましたが、それもうまくいきません。

@abritinthebay私は

確かにそれはもう少し考えられるべきです。 私の回避策は、チェーンに追加してtypeof部分を実行することでした。 例えば：

expect(somePromise.then(data => typeof data)).resolves.toBe("object");

それは機能しますが、正確にはきれいではありません。

@thymikee物事の種類をチェックすることは、十分に一般的なユースケース（普遍的）であり、それらを欠くテストフレームワークの言い訳は実際にはありません。 私たちがテストしているもののすべてのコンテキストを失うので、あなたの選択肢は受け入れられません。

このexpect(Array.isArray(['value'])).toBe(false);はで失敗します

expect(received).toBe(expected)
    Expected value to be (using ===):
      false
    Received:
      true. 

したがって、ひどいアサーションメッセージを受け取るか、これらの種類のチェックをサポートするためにJestを拡張する必要があります。 使用するすべての人がこれらの機能を独自に実装する必要があるのとは対照的に、Jestのメンテナがこれを1回行う方が理にかなっていますか？

expect.extendして独自のマッチャーを作成し、npmモジュールとして公開します。 人気が出れば、最終的にはJestコアにマージする可能性があります;）

それが欲しい人のためのシンプルなtoBeType拡張

expect.extend({
    toBeType(received, argument) {
        const initialType = typeof received;
        const type = initialType === "object" ? Array.isArray(received) ? "array" : initialType : initialType;
        return type === argument ? {
            message: () => `expected ${received} to be type ${argument}`,
            pass: true
        } : {
            message: () => `expected ${received} to be type ${argument}`,
            pass: false
        };
    }
});

describe("testing extended expect", () => {
    it("tests normal types correctly", () => {
        expect("").toBeType("string");
        expect({}).toBeType("object");
        expect(1).toBeType("number");
    });
    it("tests array types correctly", () => {
        expect([]).toBeType("array");
    });
    it("works with promises", () => {
        expect(Promise.resolve([])).resolves.toBeType("array");
    });
});

実装は非常に簡単です。 本当にコアtbhにある必要があります。

注-それはあなたのセットアップファイルに延びる入れているならば、あなたがそれをしたいsetupTestFrameworkScriptFile NOT setupFiles （として延長は前者のみで利用可能です）

ありがとう@abritinthebay

それで、人々がそれを望むなら、私はそれをnpmモジュールにまとめました：

https://www.npmjs.com/package/jest-tobetype

describe("assertion framework", ()=> {
 it("should check primitive types", () => {
   expect(expect.toBeA).toBeA("function")
  })
})

失敗：expect（...）。toBeAは関数ではありませんTypeError：expect（...）。toBeAは関数ではありません

https://github.com/jest-community/jest-extendedには、必要なすべてのタイプマッチャーがあります（私は思います）。

私はテストでtoBeInstanceOfしています：

expect($wrapper.vm.countries).toBeInstanceOf(Array);

次にexpect.extendを使用して独自のマッチャーを作成し、npmモジュールとして公開します。 人気が出れば、最終的にはJestコアにマージする可能性があります;）

ええ、そしてあなたがそれにいる間、あなた自身の冗談のフレームワークを書くかもしれません。

これは、GitHubで得られる最悪の答えを上回っている可能性があります。

したがって、 @ abritinthebayは、 @ thymikeeによって要求されたものを正確に実行しました（これは、標準のプル要求よりはるかに多かったです）。

その勇敢な魂がすべての仕事をしたので、私たちの残りはいつ最終的にこのマッチャーを手に入れることができますか（さらに別のライブラリをインストールする必要はありません）？ メンテナは、これがJestに属していないという考えをまだ推進していますか、それともこれは彼らのレーダーから外れただけですか？

私たちはそれをコアにするものにかなり厳格であり、通常はシュガーマッチャーを追加しません。 Jestコアはかなり大きなアーキテクチャであり、追加するすべてのマッチャーはメンテナンスコストを増加させます

砂糖については、一般的にhttps://github.com/jest-community/jest-extendedをお勧めし

ある人の砂糖は、コアライブラリに属する​​別の人（またはこの場合は少なくとも7人の他の人）の本当に便利で論理的な機能です。

明らかに、メンテナとしてあなたの投票は私たちのすべてに勝っています、そしてあなたは私たちがそうしないあらゆる種類の懸念を持っているので、私はそれを完全に尊重します。 しかし、ここにいる全員がこの機能がコアライブラリに属していると考える理由を見てください（非常に強力なので、1人が複数のフープを飛び越えてコードを記述しました）。 ここに必要があり、それを無視すると、Jestコアライブラリユーザー（そして正直に言うと、90％のユーザーはjest-extendedについてさえ聞いたことはありません）は失われます。

.to.be.an.instanceOfは、タイプをチェックしようと考えるユーザーの数にはならないため、それらのユーザーにとっては、たとえそれが砂糖と見なされていても、追加のライブラリなしでJestでタイプをチェックする機能を事実上拒否しています。

ええ、聞こえます。 明確にするために、「砂糖」とは、物事を読みやすく、表現しやすくするように設計された構文を意味しました。 砂糖は、定義上、すでに存在する機能のバリエーションです

この場合、次のようになります。

// Supported
expect(typeof foo).toBe('string');

// Proposed Sugar
expect(foo).toBeType('string');

したがって、タイプのチェックがサポートされていないわけではありません。 します。 最初のオプションをサポートします。 このオプションでは、バグの修正とメッセージの調整に多くの時間を費やしたコアtoBeマッチャーを使用して、ユーザーが優れたエクスペリエンスを利用できるようにします。

jest-extendedには60近くのマッチャーがあり、それらの多くは純粋な砂糖です。 これらのマッチャーのいずれについても、本当に役立つと思う人が少なくとも7人いる可能性があります。したがって、それがコアに追加するために使用したヒューリスティックである場合、マッチャーの保守だけにすべての時間を費やす可能性があります。

完全に公平であるために-ほとんどのマッチャーはあるレベルで「砂糖」です。 つまり、 toBeGreaterThanOrEqualはexpect(foo >= bar).toBe(true);単なる砂糖です

マッチャーは実際にはブール式のステートメントの周りの_ほぼすべて_の砂糖です;）

（私はこれを掘るのではなく、それが...非常にぼやけた線であることを指摘するために言っています）

abritinthebayが示唆したように、それは実際には砂糖についてではなく、「必要な」および「不必要な」（コアライブラリーにとって）砂糖についてです。 このスレッドには、「すべてのタイプをチェックできることは、テストライブラリのコアにあるべきものです」と言っている人がたくさんいます（つまり、必要です）。

私たちの言うことを聞いてください。聞いてはいけません。メンテナとして、他にもたくさんの懸念があります。 しかし、それが本質的でない場合、「あなたのものは本質的に不要な砂糖です」（つまり、私はあなたを言い換えようとしているのであり、あなたの口に言葉を入れようとしているのではありません）と言うのは正しい反応ではないと思います：それはジェストかどうか100％あなたの呼びかけですすべてのタイプをチェックできるか、箱から出していないかを確認できます。

どうですか、それは難しいことではありません：P？

expect(Array.isArray(['your', 'array'])).toBe(true);

expect(typeof something === "object").toBe(true); 
// - or -
expect(something instanceof Object).toBe(true);

expect(typeof something === "string").toBe(true); 

@nahumzs動作している間、問題は、失敗したときのテスト出力で、「falseがtrueであると予想される」と表示されることです。これはあまり役に立ちません;）

私はこれが行く方法だと思います:)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

@abritinthebayによって提供された実装をリファクタリングしました。 私には少し快適に作業できるようです。

`` `javascript
expect.extend（{
/ ** @param { }を受信しました
* @param {string | string []} arg
* @return {{pass：boolean、message：（function（）：string）}}
* /
toBeType（received、arg）{
const isCorrectType = arg => {
const receiveType =受信したtypeof;

        const checkForSingle = arg => {
            const type = receivedType === 'object'
                ? Array.isArray(received)
                    ? 'array'
                    : receivedType
                : receivedType;

            return type === arg;
        };

        const checkForArr = arg => {
            const reducer = (prev, curr) => prev || isCorrectType(curr).isCorrect;

            return arg.reduce(reducer, false);
        };

        return {
            receivedType,
            isCorrect: Array.isArray(arg)
                ? checkForArr(arg)
                : checkForSingle(arg)
        };
    };

    const {isCorrect, receivedType} = isCorrectType(arg);

    return {
        pass: isCorrect,
        message: () => {
            const toBe = Array.isArray(arg)
                ? arg.join(`' or '`)
                : arg;

            return `Expected '${received}' of '${receivedType}' type to be of '${toBe}' type(s)`;
        }
    };
}

}）;

私のモジュール（上記のリンク）をチェックしてください。 それはそれより少し多くのことをします。 しかし、それがあなたのために働くならば：それを使ってください！

私はこれが行く方法だと思います:)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

それは魅力のように機能するだけでなく、将来のためにより読みやすく、保守しやすくなります。

私はこれが行く方法だと思います:)

describe('type check', () => {
    test('should be type string', () => {
        expect(typeof '').toBe('string')
    })

    test('should be type number', () => {
        expect(typeof 10).toBe('number')
    })

    test('should be type boolean', () => {
        expect(typeof true).toBe('boolean')
    })

    test('should be type undefined', () => {
        expect(typeof undefined).toBe('undefined')
    })

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
    })

    test('should be type function', () => {
        expect(typeof function() {}).toBe('function')
    })

    test('should be type null', () => {
        expect(typeof null).toBe('object')
    })
})

    test('should be type object', () => {
        expect(typeof { foo: 'bar' }).toBe('object')
        // passes
        expect(typeof ['foo', 'bar']).toBe('object')
        // passes
        expect(typeof null).toBe('object')
    })

😞

これが、上記のアドオンを提案する理由です。これを処理します。

InstanceOfの方がわずかに優れていますが、同様の問題が発生する傾向があります。

それへのリンク：

https://www.npmjs.com/package/jest-tobetype

ソリューション@abritinthebayをありがとう

別の解決策：

expect('example').toEqual(expect.any(String));
expect(123).toEqual(expect.any(String));

2番目のものは次のように失敗します：

    Expected: Any<String>
    Received: 123