Jest: 개체, 배열 또는 문자열인지 테스트합니다.

아니요, 없습니다. 사용 가능한 모든 매처 목록은 https://facebook.github.io/jest/docs/en/expect.html 에서 찾을 수 있습니다.

lodash 와 같은 일반 JavaScript 또는 도우미 라이브러리를 사용할 수도 있습니다.

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 제가 정확히 그 상황이고 이것이 Google의 첫 번째 결과입니다. 아마도 이것을 다시 열어야 할까요?

물론 조금 더 생각해봐야 합니다. 내 해결 방법은 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의 유지 관리자가 이 작업을 한 번 수행하는 것이 더 합리적이지 않습니까?

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 setupFiles 아닌 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 는 정확히 수행했습니다 (표준 풀 요청보다 훨씬 더 많았습니다).

이제 그 용감한 영혼이 모든 작업을 수행했으므로 다른 라이브러리를 설치하지 않고도 나머지 사람들이 마침내 이 매처를 얻을 수 있는 시기는 언제입니까? 유지 관리자는 이것이 Jest에 속하지 않는다는 아이디어를 계속 추진하고 있습니까? 아니면 이것이 레이더에서 떨어진 것입니까?

우리는 그것을 핵심으로 만드는 것에 대해 매우 엄격하며 일반적으로 설탕 일치자를 추가하지 않습니다. Jest 코어는 상당히 큰 아키텍처이며 우리가 추가하는 매처마다 유지 관리 비용이 증가합니다.

설탕의 경우 일반적으로 https://github.com/jest-community/jest-extended를 권장합니다.

한 사람의 설탕은 핵심 라이브러리에 속하는 다른 사람(또는 이 경우 최소 7명의 다른 사람)의 정말 유용하고 논리적인 기능입니다.

분명히 유지 관리인으로서 귀하의 투표는 우리의 모든 것보다 우선하며 귀하는 우리가 생각하지 않는 모든 종류의 우려를 가지고 있으므로 저는 그것을 전적으로 존중합니다. 하지만 여기 있는 모든 사람들이 왜 이 기능이 핵심 라이브러리에 속한다고 생각하는지 살펴보시기 바랍니다. 여기에 필요가 있으며 이를 무시하면 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개의 matchers가 있으며 그 중 많은 것이 순수한 설탕입니다. 이러한 매처의 경우 최소한 7명의 다른 사람들이 정말 유용하다고 생각할 수 있으므로 코어에 추가하는 데 사용한 경험적 방법이라면 아마 매처를 유지 관리하는 데 모든 시간을 할애할 것입니다.

완전히 공정하기 위해 - 대부분의 매처는 어느 정도는 "설탕"입니다. 내 말은 toBeGreaterThanOrEqual 는 expect(foo >= bar).toBe(true); 대한 설탕일 뿐입니다.

매처는 실제로 _거의 모든_ 부울 문에 대한 설탕입니다. ;)

(파는 것이 아니라 단지 그것이... 매우 흐릿한 선이라는 것을 지적하기 위해 이 말을 하는 것입니다.)

abritinthebay가 제안한 것처럼 설탕에 관한 것이 아니라 "필수" 및 "불필요한"(핵심 라이브러리의 경우) 설탕에 관한 것입니다. 이 스레드에서 "이봐, 모든 유형을 확인할 수 있다는 것은 테스트 라이브러리의 핵심에 있어야 하는 것"이라고 말하는 많은 사람들이 있습니다(즉, 필요합니다).

우리의 말을 듣거나 듣지 마십시오. 다시 한 번 유지 관리자로서 다른 많은 우려 사항이 있습니다. 하지만 내 생각에 그것이 내재적이지 않을 때 "당신의 것은 본질적으로 불필요한 설탕입니다"라고 말하는 것이 올바른 응답이라고 생각하지 않습니다. 모든 유형을 확인하거나 즉시 확인할 수 없습니다.

어때요, 어렵지 않아요 :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 작동하는 동안 문제는 테스트 출력에서 ​​실패할 때 '거짓이 사실일 것으로 예상됨'이라고 표시되어 그다지 도움이 되지 않는다는 것입니다. ;)

가는 길인 것 같아요 :)

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에서 제공하는 구현을 리팩토링했습니다. 작업하기에는 조금 편한 것 같습니다.

```자바스크립트
기대.확장({
/ ** @param { } 수신됨
* @param {문자열|문자열[]} 인수
* @return {{통과:부울, 메시지:(함수():문자열)}}
*/
toBeType(수신, 인수) {
상수 isCorrectType = 인수 => {
const receiveType = 수신된 유형;

        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

솔루션 @abritinbay에 감사드립니다

또 다른 솔루션:

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

두 번째는 다음과 같이 실패합니다.

    Expected: Any<String>
    Received: 123