Obtendo “NoSuchMethodError: org.hamcrest.Matcher.describeMismatch” ao executar o teste no IntelliJ 10.5

Estou usando o JUnit-dep 4.10 e o Hamcrest 1.3.RC2.

Eu criei um correspondente personalizado que se parece com o seguinte:

public static class MyMatcher extends TypeSafeMatcher<String> {
    @Override
    protected boolean matchesSafely(String s) {
        /* implementation */
    }

    @Override
    public void describeTo(Description description) {
        /* implementation */
    }

    @Override
    protected void describeMismatchSafely(String item, Description mismatchDescription) {

        /* implementation */
    }
}

Funciona perfeitamente quando executado a partir da linha de comando usando o Ant. Mas quando executado no IntelliJ, ele falha com:

java.lang.NoSuchMethodError: org.hamcrest.Matcher.describeMismatch(Ljava/lang/Object;Lorg/hamcrest/Description;)V
    at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:18)
    at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:8)
    at com.netflix.build.MyTest.testmyStuff(MyTest.java:40)

Meu palpite é que ele está usando o hamcrest.MatcherAssert errado. Como encontro qual hamcrest.MatcherAssert está sendo usado (ou seja, qual arquivo jar está sendo usado para hamcrest.MatcherAssert)? AFAICT, os únicos frascos de hamcrest no meu caminho de classe é 1.3.RC2.

O IntelliJ IDEA está usando sua própria cópia do JUnit ou Hamcrest?

Como eu produzo o CLASSPATH de tempo de execução que o IntelliJ está usando?

Verifique se o jarro de hamcrest é mais alto no pedido de importação do que o seu jar JUnit .

O JUnit vem com sua própria org.hamcrest.Matcherclasse que provavelmente está sendo usada.

Você também pode fazer o download e usar o junit-dep-4.10.jar em vez disso, que é o JUnit sem as classes hamcrest.

O mockito também possui as classes mais vazias, então você pode precisar movê-lo / reordená-lo

Esse problema também surge quando você tem mockito-all no caminho da classe, que já está obsoleto.

Se possível, inclua mockito-core .

Configuração do Maven para misturar junit, mockito e hamcrest:

<dependencies>
  <dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest-core</artifactId>
    <version>1.3</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest-library</artifactId>
    <version>1.3</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.9.5</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
</dependencies>

O problema era que a classe errada hamcrest.Matcher, e não hamcrest.MatcherAssert, estava sendo usada. Isso estava sendo extraído de uma dependência junit-4.8 que uma das minhas dependências estava especificando.

Para ver quais dependências (e versões) estão incluídas em qual fonte durante o teste, execute:

mvn dependency:tree -Dscope=test

O seguinte deve ser o mais correto hoje. Observe, a junção 4.11 depende do hamcrest-core, portanto, não é necessário especificar que o mockito-all não possa ser usado, pois inclui (não depende) hamcrest 1.1

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>1.10.8</version>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Isso funcionou para mim depois de lutar um pouco

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest-all</artifactId>
    <version>1.3</version>
    <scope>test</scope>
 </dependency>

 <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.9.5</version>
    <scope>test</scope>
 </dependency>

 <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
 </dependency>

Experimentar

expect(new ThrowableMessageMatcher(new StringContains(message)))

ao invés de

expectMessage(message)

Você pode escrever um ExpectedExceptionmétodo personalizado ou utilitário para agrupar o código.

Eu sei que esse é um thread antigo, mas o que resolveu o problema foi adicionar o seguinte aos meus arquivos build.gradle. Como já foi dito acima, há um problema de compatibilidade commockito-all

Mensagem possivelmente útil :

testCompile ('junit:junit:4.12') {
    exclude group: 'org.hamcrest'
}
testCompile ('org.mockito:mockito-core:1.10.19') {
    exclude group: 'org.hamcrest'
}
testCompile 'org.hamcrest:hamcrest-core:1.3'

Apesar de ser uma pergunta muito antiga e provavelmente muitas das idéias mencionadas resolverem muitos problemas, ainda quero compartilhar a solução com a comunidade que resolveu o meu problema.

Eu descobri que o problema era uma função chamada "hasItem" que eu estava usando para verificar se um JSON-Array contém ou não um item específico. No meu caso, verifiquei um valor do tipo Long.

E isso levou ao problema.

De alguma forma, os Matchers têm problemas com valores do tipo Long. (Eu não uso tanto o JUnit ou o Rest-Assured quanto o idk. Exatamente por que, mas acho que os dados JSON retornados contêm apenas números inteiros.)

Então, o que eu fiz para resolver o problema foi o seguinte. Ao invés de usar:

long ID = ...;

...
.then().assertThat()
  .body("myArray", hasItem(ID));

você só precisa converter para Inteiro. Portanto, o código de trabalho ficou assim:

long ID = ...;

...
.then().assertThat()
  .body("myArray", hasItem((int) ID));

Essa provavelmente não é a melhor solução, mas eu só queria mencionar que a exceção também pode ser lançada devido a tipos de dados errados / desconhecidos.

O que funcionou para mim foi excluir o grupo hamcrest da compilação do teste junit.

Aqui está o código do meu build.gradle:

testCompile ('junit:junit:4.11') {
    exclude group: 'org.hamcrest'
}

Se você estiver executando o IntelliJ, poderá ser necessário executar gradle cleanIdea idea clean buildpara detectar as dependências novamente.

Sei que essa não é a melhor resposta, mas se você não conseguir fazer o caminho de classe funcionar, essa é uma solução do plano B.

No meu caminho de classe de teste, adicionei a seguinte interface com uma implementação padrão para o método descrevMismatch.

package org.hamcrest;

/**
 * PATCH because there's something wrong with the classpath. Hamcrest should be higher than Mockito so that the BaseMatcher
 * implements the describeMismatch method, but it doesn't work for me. 
 */
public interface Matcher<T> extends SelfDescribing {

    boolean matches(Object item);

    default void describeMismatch(Object item, Description mismatchDescription) {
        mismatchDescription.appendDescriptionOf(this).appendValue(item);
    }

    @Deprecated
    void _dont_implement_Matcher___instead_extend_BaseMatcher_();
}

Eu tenho um projeto gradle e quando minha seção de dependências build.gradle se parece com isso:

dependencies {
    implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.8.1'

    testImplementation group: 'org.mockito', name: 'mockito-all', version: '1.10.19'
    testImplementation 'junit:junit:4.12'
//    testCompile group: 'org.mockito', name: 'mockito-core', version: '2.23.4'

    compileOnly 'org.projectlombok:lombok:1.18.4'
    apt 'org.projectlombok:lombok:1.18.4'
}

isso leva a esta exceção:

java.lang.NoSuchMethodError: org.hamcrest.Matcher.describeMismatch(Ljava/lang/Object;Lorg/hamcrest/Description;)V

    at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:18)
    at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:8)

Para corrigir esse problema, substituí "mockito-all" por "mockito-core".

dependencies {
    implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.8.1'

//    testImplementation group: 'org.mockito', name: 'mockito-all', version: '1.10.19'
    testImplementation 'junit:junit:4.12'
    testCompile group: 'org.mockito', name: 'mockito-core', version: '2.23.4'

    compileOnly 'org.projectlombok:lombok:1.18.4'
    apt 'org.projectlombok:lombok:1.18.4'
}

A explicação entre mockito-all e mockito-core pode ser encontrada aqui: https://solidsoft.wordpress.com/2012/09/11/beyond-the-mockito-refcard-part-3-mockito-core-vs-mockito -todos os projetos baseados em graduação /

O mockito-all.jar além do próprio Mockito contém também (a partir do 1.9.5) duas dependências: Hamcrest e Objenesis (vamos omitir o ASM e o CGLIB reembalados por um momento). O motivo era ter tudo o que é necessário dentro de um JAR para colocá-lo em um caminho de classe. Pode parecer estranho, mas lembre-se de que o desenvolvimento do Mockito começou nos tempos em que o Ant puro (sem gerenciamento de dependências) era o sistema de construção mais popular para projetos Java e todos os JARs externos exigidos por um projeto (ou seja, as dependências do nosso projeto e suas dependências) tinham para ser baixado manualmente e especificado em um script de construção.

Por outro lado, mockito-core.jar é apenas classes Mockito (também com ASM e CGLIB reembalado). Ao usá-lo com Maven ou Gradle, as dependências necessárias (Hamcrest e Objenesis) são gerenciadas por essas ferramentas (baixadas automaticamente e colocadas em um caminho de classe de teste). Ele permite substituir as versões usadas (por exemplo, se nossos projetos usam nunca, mas a versão compatível com versões anteriores), mas o mais importante é que essas dependências não estejam ocultas no mockito-all.jar, o que permite detectar uma possível incompatibilidade de versão com as ferramentas de análise de dependência. Essa é uma solução muito melhor quando a ferramenta gerenciada por dependência é usada em um projeto.

No meu caso, tive que excluir um hamcrest mais antigo do junit-vintage:

<dependency>
  <groupId>org.junit.vintage</groupId>
  <artifactId>junit-vintage-engine</artifactId>
  <scope>test</scope>
  <exclusions>
    <exclusion>
      <groupId>org.hamcrest</groupId>
      <artifactId>hamcrest-core</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.hamcrest</groupId>
  <artifactId>hamcrest</artifactId>
  <version>2.1</version>
  <scope>test</scope>
</dependency>

Isso funcionou para mim. Não há necessidade de excluir nada. Eu apenas usei mockito-corevezmockito-all

testCompile 'junit:junit:4.12'
testCompile group: 'org.mockito', name: 'mockito-core', version: '3.0.0'
testCompile group: 'org.hamcrest', name: 'hamcrest-library', version: '2.1'