Jest: Uji apakah objek, larik, atau string.

Tidak, tidak ada. Anda akan menemukan daftar semua pencocokan yang tersedia di sini: https://facebook.github.io/jest/docs/en/expect.html

Anda juga dapat menggunakan JavaScript biasa atau pustaka pembantu seperti lodash untuk itu:

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');
})

Poin kecil - ini tidak membantu dengan hasil yang menjanjikan.

expect(somePromise).resolves.toBe(...) saat ini tidak ada cara untuk memeriksa jenis. Jika Anda tidak peduli apa isinya tetapi hanya bahwa itu adalah string. Saya berharap expects.stringContaining("") menjadi solusi tetapi itu tidak berhasil juga.

@abritinthebay Saya persis seperti itu dan ini adalah hasil pertama di Google, mungkin ini harus dibuka kembali?

Tentu saja itu harus dipikirkan sedikit lebih banyak. Solusi saya adalah menambahkan ke rantai sehingga melakukan bagian typeof . misalnya:

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

berfungsi, tetapi tidak sepenuhnya bersih.

@thymikee Memeriksa jenis hal adalah kasus penggunaan yang cukup umum (universal) sehingga sebenarnya tidak ada alasan untuk kerangka pengujian yang tidak memilikinya. Alternatif Anda tidak dapat diterima karena kami kehilangan semua konteks dari apa yang kami uji.

expect(Array.isArray(['value'])).toBe(false); gagal dengan

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

Jadi kami mendapatkan pesan pernyataan yang buruk atau kami harus memperluas Jest untuk mendukung pemeriksaan semacam ini. Bukankah lebih masuk akal bagi pengelola Jest untuk melakukan ini sekali dibandingkan dengan setiap orang yang menggunakan memerlukan fitur-fitur ini untuk mengimplementasikannya sendiri?

Buat matcher Anda sendiri dengan expect.extend lalu dan publikasikan sebagai modul npm. Jika menjadi populer, kami dapat menggabungkannya ke inti Jest pada akhirnya;)

Ekstensi toBeType sederhana untuk mereka yang menginginkannya

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");
    });
});

Cukup sederhana untuk diterapkan. Benar-benar harus di tbh inti.

Catatan - jika Anda meletakkan ekstensi itu di file pengaturan Anda, maka Anda menginginkannya di setupTestFrameworkScriptFile BUKAN setupFiles (karena perpanjangan hanya tersedia di yang pertama)

Terima kasih @abritinthebay

Jadi saya membungkusnya dalam modul npm jika orang menginginkannya:

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

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

Gagal: harapkan(...).toBeA bukan fungsiTypeError: expect(...).toBeA bukan fungsi

https://github.com/jest-community/jest-extended memiliki semua jenis pencocokan yang Anda inginkan (saya pikir).

Saya telah menggunakan toBeInstanceOf dalam pengujian saya:

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

Buat matcher Anda sendiri dengan expect.extend lalu dan publikasikan sebagai modul npm. Jika menjadi populer, kami dapat menggabungkannya ke inti Jest pada akhirnya;)

Ya, dan mungkin menulis kerangka lelucon Anda sendiri, saat Anda melakukannya.

Yang ini mungkin menjadi jawaban terburuk yang bisa Anda dapatkan di GitHub.

Jadi @abritinthebay melakukan persis apa yang diminta oleh @thymikee (yang jauh lebih banyak daripada permintaan tarik standar).

Sekarang setelah jiwa pemberani itu melakukan semua pekerjaan, kapan kita semua akhirnya bisa mendapatkan korek api ini (tanpa harus menginstal perpustakaan lain)? Apakah pengelola masih mendorong gagasan bahwa ini bukan milik Jest, atau apakah ini jatuh dari radar mereka?

Kami cukup ketat dengan apa yang membuatnya menjadi inti dan biasanya tidak menambahkan korek api gula. Inti lelucon adalah arsitektur yang cukup besar dan setiap pencocokan yang kami tambahkan meningkatkan biaya pemeliharaan

Untuk gula, kami biasanya merekomendasikan https://github.com/jest-community/jest-extended

Gula satu orang adalah milik orang lain (atau dalam hal ini, setidaknya tujuh orang lain) benar-benar berguna dan fitur logis yang termasuk dalam perpustakaan inti.

Jelas sebagai pengelola, suara Anda mengalahkan kami semua, dan Anda memiliki segala macam kekhawatiran yang tidak kami lakukan, jadi saya sepenuhnya menghormati itu. Tapi saya hanya meminta Anda melihat mengapa semua orang di sini menganggap fitur ini termasuk dalam perpustakaan inti (begitu kuat sehingga satu orang melompati banyak rintangan untuk menulis kode untuk Anda). Ada kebutuhan di sini, dan jika Anda mengabaikannya, pengguna perpustakaan inti Jest (dan jujur ​​​​saja, 90% dari mereka bahkan tidak akan pernah mendengar tentang diperpanjang lelucon) akan kalah.

.to.be.an.instanceOf tidak akan menjadi berapa banyak pengguna yang berpikir untuk memeriksa jenis, jadi bagi pengguna tersebut, bahkan jika Anda melihatnya sebagai gula, Anda secara efektif menolak kemampuan mereka untuk memeriksa jenis di Jest tanpa perpustakaan tambahan.

Ya saya dengar ya. Untuk lebih jelasnya, dengan "gula" yang saya maksud adalah sintaksis yang dirancang untuk membuat segalanya lebih mudah dibaca atau diungkapkan . Gula, menurut definisi, adalah variasi dari fitur yang sudah ada

Dalam hal ini, kami memiliki:

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

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

Jadi bukan berarti kami tidak mendukung jenis pemeriksaan. Kami melakukannya. Kami mendukung opsi pertama. Opsi ini menggunakan inti toBe matcher yang telah kami habiskan banyak waktu untuk memperbaiki bug, dan mengutak-atik pesan, sehingga pengguna memiliki pengalaman yang baik

Ada hampir 60 korek api dalam lelucon dan banyak di antaranya adalah gula murni. Untuk matcher mana pun, Anda mungkin dapat menemukan setidaknya 7 orang lain yang menganggapnya sangat berguna, jadi jika itu adalah heuristik yang kami gunakan untuk menambahkan ke inti, kami mungkin akan menghabiskan seluruh waktu kami hanya untuk mempertahankan matcher

Agar benar-benar adil - kebanyakan korek api adalah "gula" pada tingkat tertentu. Maksud saya toBeGreaterThanOrEqual hanyalah gula untuk expect(foo >= bar).toBe(true);

Pencocokan benar-benar _hampir semua_ gula di sekitar pernyataan boolean;)

(Saya mengatakan ini bukan untuk menggali, hanya untuk menunjukkan bahwa itu... garis yang sangat kabur)

Seperti yang disarankan abritinthebay, ini bukan tentang gula, ini tentang gula "perlu" dan "tidak perlu" (untuk perpustakaan inti). Anda memiliki banyak orang di utas ini yang mengatakan "hei, dapat memeriksa semua jenis adalah sesuatu yang harus menjadi inti dari perpustakaan pengujian" (mis.

Dengarkan kami atau tidak, sekali lagi sebagai pengelola Anda memiliki banyak masalah lain. Tapi saya tidak berpikir tanggapan yang tepat adalah dengan mengatakan "milik Anda pada dasarnya tidak perlu gula" (itu saya mencoba memparafrasekan Anda, tidak mencoba memasukkan kata-kata ke dalam mulut Anda) ketika itu tidak melekat: itu 100% panggilan Anda apakah Jest dapat memeriksa semua jenis atau tidak di luar kotak.

gimana, susah kan :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 Saat berfungsi, masalahnya adalah pada hasil pengujian Anda ketika gagal, ia akan mengatakan 'diharapkan salah menjadi benar', yang tidak terlalu membantu;)

Saya pikir ini adalah cara untuk pergi :)

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')
    })
})

Saya memfaktorkan ulang implementasi yang disediakan oleh @abritinthebay. Tampaknya bagi saya sedikit nyaman untuk bekerja dengannya.

```javascript
harapkan.perpanjang({
/ ** @param { } diterima
* @param {string|string[]} argumen
* @return {{pass:boolean,pesan:(fungsi():string)}}
*/
toBeType(diterima, arg) {
const isCorrectType = arg => {
const diterimaTipe = tipe diterima;

        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)`;
        }
    };
}

});

Anda harus memeriksa modul saya (ditautkan di atas). Itu sedikit lebih dari itu. Tetapi jika itu berhasil untuk Anda: gunakan!

Saya pikir ini adalah cara untuk pergi :)

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')
    })
})

Ini berfungsi seperti pesona serta lebih mudah dibaca dan dipelihara untuk masa depan.

Saya pikir ini adalah cara untuk pergi :)

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')
    })

😞

Inilah mengapa saya menyarankan addon saya di atas: menangani ini.

InstanceOf sedikit lebih baik tetapi rentan terhadap masalah serupa.

Tautan ke sana:

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

terima kasih atas solusinya @abritinthebay

Solusi lain:

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

Yang kedua akan gagal dengan:

    Expected: Any<String>
    Received: 123