Activitats

Un usuari només ha de respondre un cop a una pregunta

L’objectiu d’aquesta activitat és canviar la implementació de QuestionService per tal que un usuari només pugui contestar un cop una pregunta.

A partir del següent

codi ( 30.3 KB )

, modifiqueu QuestionService afegint el mètode hasUserAnsweredTheQuestion i afegiu la seva implementació a QuestionServiceImpl.

Creeu també un nou mètode UserDAO.findAnswers que retorni totes les respostes d’un usuari i utilitzeu-lo a la implementació de hasUserAnsweredTheQuestion.

public Boolean hasUserAnsweredTheQuestion(Integer questionId, Integer userId);

public interface UserDAO {
    public Set<Answer> findAnswers(Integer userId);
}
 
@Repository("userHibernateDAO")
@Transactional
public class UserHibernateDAO implements UserDAO {
  @Override
  public Set<Answer> findAnswers(Integer userId){
      User user = getById(userId);
      return user.getAnswers();
  }
}
 
@Transactional
public class QuestionServiceImpl implements QuestionService {
 
  @Override
  public Question addAnswer(Answer answer, Integer questionId, Integer userId) {
      Question question = questionDAO.getById(questionId);
      if(!hasUserAnsweredTheQuestion(questionId, userId)){
          User user = userDAO.getById(userId);
          Set<Answer> userAnswers = user.getAnswers();
          addAnswerToCollection(answer, userAnswers);
          user.setAnswers(userAnswers);
          userDAO.save(user);
 
 
          Set<Answer> answers = question.getAnswers();
          answers = addAnswerToCollection(answer, answers);
          question.setAnswers(answers);
          questionDAO.update(question);
      }
      return question;
  }
 
  @Override
  public Boolean hasUserAnsweredTheQuestion(Integer questionId, Integer userId) {
      Question question = questionDAO.getById(questionId);
      Set<Answer> answers = question.getAnswers();
      Set<Answer> userAnswers = userDAO.findAnswers(userId);
      if(!userAnswers.isEmpty()){
          userAnswers.retainAll(answers);
          return userAnswers.size() > 0;
      }
      return false;
  }
 
}

Per tal que Set.retailAll trobi les preguntes contingudes als sets answers i userAnswers s’ha d’especificar què vol dir aquesta igualtat. En el cas de Answers, dues preguntes seran igual si tenen el mateix valor que answerId.

@Entity
@Table(name = "answers")
public class Answer implements Serializable {
  @Override
  public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;
      Answer answer = (Answer) o;
 
      return !(getAnswerId() != null ? !getAnswerId().equals(answer.getAnswerId()) : answer.getAnswerId() != null);
  }
 
  @Override
  public int hashCode() {
      return getText() != null ? getText().hashCode() : 0;
  }
}

Detecció dels usuaris que ja han contestat preguntes

L’objectiu d’aquesta activitat és escriure els tests necessaris per detectar si un usuari ja ha contestat una pregunta. Per fer-ho, afegiu tests a QuestionServiceTest i UserHibernateDAO i creeu el test org.ioc.daw.answer.AnswerTest que comprovi que la implementació de la igualtat és correcta.

public class AnswerTest {
  @Test
  public void checkAnswersAreEqual() {
      Answer answer1 = new Answer();
      answer1.setAnswerId(1);
      answer1.setText("Answer1");
      Answer answer2 = new Answer();
      answer2.setAnswerId(1);
      answer2.setText("Answer1");
      Assert.assertTrue(answer2.equals(answer1));
  }
 
  @Test
  public void checkAnswersAreDifferent() {
      Answer answer1 = new Answer();
      answer1.setAnswerId(1);
      answer1.setText("Answer1");
      Answer answer2 = new Answer();
      answer2.setAnswerId(2);
      answer2.setText("Answer2");
      Assert.assertFalse(answer2.equals(answer1));
  }
}
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {EmbeddedDatabaseTestConfig.class})
public class UserDAOTest {
  @Test
  public void findAllUserAnswers() {
      User user1 =new User();
      user1.setUsername("test");
      user1.setActive(true);
      user1.setEmail(""email@test.com");
      user1.setPassword("password");
      user1.setName("name");
      user1.setCreatedOn(new Timestamp(new Date().getTime()));
 
      Answer answer1 = new Answer();
      answer1.setText("Answer1");
      Answer answer2 = new Answer();
      answer2.setText("Answer2");
      Set<Answer> answers = new HashSet<>();
      answers.add(answer1);
      answers.add(answer2);
      user1.setAnswers(answers);
      userDAO.create(user1);
 
      User userFromDB = userDAO.getById(user1.getUserId());
      assertEquals(2, userFromDB.getAnswers().size());
  }
}

Abans d’executar els tests (@Before) utilitzarem el mètode Mockito.reset per evitar que hi hagi efectes residuals dels mocks en els diferents tests.

@ContextConfiguration(classes = {SpringTestConfig.class})
public class QuestionServiceTest {
  @Before
  public void setUp(){
      Mockito.reset(questionDAOMock);
      Mockito.reset(userDAOMock);
  }
 
  @Test
  public void checkUserCanOnlyAnswerOnce() {
      int userID = 1;
      int questionId = 1;
      int answerId = 1;
      Question question1 = getDummyQuestion(questionId);
      Answer answer1 = getDummyAnswer(answerId);
      Set<Answer> answers = new HashSet<>();
      answers.add(answer1);
      question1.setAnswers(answers);
      when(questionDAOMock.getById(questionId)).thenReturn(question1);
 
      User user1 = getDummyUser(userID);
      Answer userAnswer1 = getDummyAnswer(answerId);
      Answer userAnswer2 = getDummyAnswer(2);
      Set<Answer> userAnswers = new HashSet<>();
      userAnswers.add(userAnswer1);
      userAnswers.add(userAnswer2);
      user1.setAnswers(userAnswers);
      when(userDAOMock.getById(userID)).thenReturn(user1);
 
      verify(questionDAOMock, never()).update(Mockito.any(Question.class));
  }
}
 
@Import(value = {ServicesConfig.class})
public class SpringTestConfig {
    @Bean
    public UserDAO userDAO() {
        return Mockito.mock(UserDAO.class);
    }
 
    @Bean
    public QuestionDAO questionDAO() {
        return Mockito.mock(QuestionDAO.class);
    }
 
    @Bean
    public AnswerDAO answerDAO() {
        return Mockito.mock(AnswerDAO.class);
    }
 
    @Bean
    public PlatformTransactionManager transactionManager() {
        return Mockito.mock(PlatformTransactionManager.class);
    }
 
}