# 喝一杯mockito

mockito 是最常用的 java mock 库， 用于模拟创建各种对象和行为。本文会介绍一下 基础库 mockitio的用法，进行一些练习。mockitio 通常不单独使用，配合 Junit一起使用。



下面列举一下用法,

# 模拟对象
创建mock 对象，并且可以要求，这个对象的成员方法符合我们的行为要求。

```
    Foo foo= Mockito.mock(Foo.class);
```

---

# 直接返回

直接返回，我们需要的值

when thenReturn
```
  @Test
  void returnWhatIWant() {
    Foo mock = Mockito.mock(Foo.class);
    Mockito.when(mock.say()).thenReturn("nice to meet you");
    String result = mock.say();
    Assertions.assertEquals("nice to meet you", result);
  }
```

---

# 定制方法

定制方法，改变方法的实现
when thenAnswer
```
@Test
void returnBaseOneParamOrSomething() {
  Foo mock = Mockito.mock(Foo.class);
  Mockito.when(mock.echo(anyString()))
      .thenAnswer(
          new Answer<String>() {
            @Override
            public String answer(InvocationOnMock invocationOnMock) throws Throwable {
              String argument = invocationOnMock.getArgument(0, String.class);
              return "hi,"+argument;
            }
          });
  String result = mock.echo("all");
  Assertions.assertEquals("hi,all", result);
}
```

---

 # 验证方法执行次数 和 时间


```
  @Test
  void verifyMethod() {
    Foo foo = Mockito.mock(Foo.class);
    foo.say();

    Mockito.verify(foo).say();
    Mockito.verify(foo, Mockito.times(1)).say();
    Mockito.verify(foo, Mockito.timeout(1000)).say();
  }
```

---

# 模拟静态方法


改变静态方法的行为（使用 mockito-inline 作为依赖）

```
@Test
  void mockStaticMethod() {
    try (MockedStatic<Foo> fooMockedStatic = Mockito.mockStatic(Foo.class)) {
      fooMockedStatic.when(() -> Foo.hold()).thenReturn("hi");
      String result = Foo.hold();
      Assertions.assertEquals("hi", result);
    }
    
    try(MockedStatic<Foo> fooMockedStatic = Mockito.mockStatic(Foo.class)) {
      fooMockedStatic.when(()->Foo.reply(anyString())).thenAnswer(
          new Answer<String>() {
            @Override
            public String answer(InvocationOnMock invocationOnMock) throws Throwable {
              String arg = invocationOnMock.getArgument(0,String.class);
              return "hi," + arg;
            }
          }
      );
      String result = Foo.reply("1024");
      Assertions.assertEquals("hi,1024",result);
    }
  }
```

---

# 模拟构造函数

改名构造函数的行为，使得创建出来的都是模拟对象。
```
@Test
  void mockConstruction() {
    try (MockedConstruction<Foo> fooMockedConstruction = Mockito.mockConstruction(Foo.class)) {
      Foo foo = new Foo();
      foo.say();
      Mockito.verify(foo).say();
    }

    try (MockedConstruction<Foo> fooMockedConstruction =
        Mockito.mockConstruction(
            Foo.class,
            new MockedConstruction.MockInitializer<Foo>() {
              @Override
              public void prepare(Foo foo1, MockedConstruction.Context context) {
                Mockito.when(foo1.say()).thenReturn("mock");
              }
            })) {
      Foo foo3 = new Foo();
      String result = foo3.say();
      Mockito.verify(foo3, Mockito.times(1)).say();

      Assertions.assertEquals("mock", result);
    }
  }
```
# 参数匹配
只对某个方法的特定参数进行模拟，其他参数不模拟

```
  @Test
  void mockSpecificArgument() {
    Foo foo = Mockito.mock(Foo.class);
    Mockito.when(foo.echo(eq("hello"))).thenReturn("nonono");
    Assertions.assertEquals("nonono", foo.echo("hello"));
    Mockito.verify(foo).echo("hello");

    Assertions.assertNull(foo.echo("other"));
    Mockito.verify(foo).echo("other");
  }
```
# 待续

TBD


总结，上面是我常用的一些 mockito 方法。