UserRepositoryTest.java

package com.clouway.telcong.pubsub;

import org.jmock.Expectations;
import org.jmock.integration.junit4.JUnitRuleMockery;
import org.junit.Rule;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

/**
 * @author Miroslav Genov (miroslav.genov@clouway.com)
 */
public class UserRepositoryTest {

  @Rule
  public JUnitRuleMockery context = new JUnitRuleMockery();

  private UserRepository userRepository = new UserRepository(20, new InMemoryUserDb());

  @Test
  public void userIsAdult() {
    final UserDb userDb = context.mock(UserDb.class);
    final User user = new User("John", 20);

    context.checking(new Expectations() {{
      oneOf(userDb).findUserByName(with(any(String.class)));
      will(returnValue(user));
    }});

    UserRepository userRepository = new UserRepository(20, userDb);
    assertThat(userRepository.isAdult("John"), is(true));
  }

  @Test
  public void userNameIsProvidedForLookupByName() throws Exception {
    final UserDb userDb = context.mock(UserDb.class);
    final User user = new User("John", 20);

    context.checking(new Expectations() {{
      oneOf(userDb).findUserByName("John");
      will(returnValue(user));
    }});

    UserRepository userRepository = new UserRepository(20, userDb);
    userRepository.isAdult("John");
  }

  @Test(expected = IllegalArgumentException.class)
  public void unknownUserWasCheckedWithMocks() throws Exception {
    final UserDb userDb = context.mock(UserDb.class);

    context.checking(new Expectations() {{
      oneOf(userDb).findUserByName("John");
      will(throwException(new IllegalArgumentException("::any message::")));
    }});

    UserRepository userRepository = new UserRepository(20, userDb);
    userRepository.isAdult("John");
  }

  @Test
  public void oneIsAdultOneIsNot() {
    UserRepository userRepository = new UserRepository(20, new InMemoryUserDb(
            Arrays.asList(
                    new User("John", 20),
                    new User("Peter", 10)
            )
    ));

    assertThat(userRepository.isAdult("John"), is(true));
    assertThat(userRepository.isAdult("Peter"), is(false));
  }

  @Test
  public void noOneIsAdultsFromMany() throws Exception {
    InMemoryUserDb usersDb = new InMemoryUserDb();
    usersDb.registerUser(new User("John", 10));
    usersDb.registerUser(new User("Peter", 12));

    UserRepository userRepository = new UserRepository(20, usersDb);

    assertThat(userRepository.isAdult("John"), is(false));
    assertThat(userRepository.isAdult("Peter"), is(false));
  }

  @Test(expected = IllegalArgumentException.class)
  public void unknownUserWasChecked() throws Exception {
    userRepository.isAdult("::unknown name::");
  }

  @Test
  public void userCustomAdultAges() throws Exception {
    InMemoryUserDb usersDb = new InMemoryUserDb();
    usersDb.registerUser(new User("John", 22));
    usersDb.registerUser(new User("Peter", 19));

    UserRepository userRepository = new UserRepository(20, usersDb);

    assertThat(userRepository.isAdult("John"), is(true));
    assertThat(userRepository.isAdult("Peter"), is(false));
  }


  class User {
    public final String name;
    public final int age;

    public User(String name, int age) {

      this.name = name;
      this.age = age;
    }
  }

  interface UserDb {

    User findUserByName(String name);

  }

  class UserRepository {
    private final int adultAges;
    private final UserDb userDb;

    public UserRepository(int adultAges, UserDb userDb) {
      this.adultAges = adultAges;
      this.userDb = userDb;
    }


    public boolean isAdult(String name) {
      User user = userDb.findUserByName(name);
      return user.age >= adultAges;
    }

  }

  private class InMemoryUserDb implements UserDb {
    private final List<User> users = new ArrayList<>();

    public InMemoryUserDb() {

    }

    public InMemoryUserDb(List<User> users) {
      this.users.addAll(users);
    }

    public void registerUser(User user) {
      users.add(user);
    }

    @Override
    public User findUserByName(String name) {
      for (User user : users) {
        if (user.name.equals(name)) {
          return user;
        }
      }
      throw new IllegalArgumentException("User with name " + name + " was not registered.");
    }
  }
}