current community

your communities

more stack exchange communities

Stack Exchange
tour help
Take the 2-minute tour ×
Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.
up vote 5 down vote favorite

I am using JUnit, Hibernate and Spring Framework. I wrote a simple test to test whether entity was updated correctly or not.

Is this correct way to test if entity was updated? Could it be done better?

@Test
public void testUpdated(){
    ConfirmationEntity confirmationEntity = confirmationDao.find(1L);
    confirmationEntity.setConfirmationString("0123456789");
    confirmationEntity.setConfirmationStringValidUntil(new LocalDateTime());

    confirmationDao.update(confirmationEntity);

    ConfirmationEntity confirmationEntityUpdated = confirmationDao.find(1L);

    Assert.assertSame(
        "Expected values to be the same.", 
        confirmationEntity, 
        confirmationEntityUpdated
    );
}
share|improve this question

1 Answer 1

up vote 4 down vote accepted

This test, on its own, is not enough. Additionally, the test is called testUpdated, but it does not actually test that the value is updated.

What it does is:

  • find an object based on a key value
  • it modifies some non-key content
  • it 'persists' the changes
  • it finds an object for the same key as before
  • it tests that the object it found the second time is the identical object to the first.

At no point in this process have you actually tested that the values you think you changed on the object, actually did change.

Additionally, you never tested whether those changes were persisted to the database/store.

What I would expect a test like this to do, is to:

  • get the object using the key
  • make the changes
  • assert that the values have changed to the new values.
  • persist the changes
  • assert that a persist happened (some timestamp in the database maybe)?
  • use an independent mechanism to check that the values in the database match the values in the object (a different database connection, a different DAO instance, something).
  • ensure that finding the same key value finds the same instance as before.

That is a lot of things to change, which means the test, on it's own, is not enough, and should be included with a bunch of other tests, each one testing different parts of the process.

share|improve this answer
    
"At no point in this process have you actually tested that the values you think you changed on the object, actually did change." - The entity is just simple POJO object with getter and setter methods, do you really think that it is necessary to actually test if values were set? "Additionally, you never tested whether those changes were persisted to the database/store." - If values weren't persisted to database, then confirmationEntity and confirmationEntityUpdated wouldn't be the same ... –  Chorochrondochor May 15 '14 at 10:11
    
@Chorochrondochor - assertSame(...) means that confirmationEntity == confirmationEntityUpdated ... which means, I can guarantee, that you did not create a new instance when you pulled the values from the database for the second find(...) Either that, or your test is failing. Do you think you are using assertEquals(...) ? (which is very different to assertSame(...). –  rolfl May 15 '14 at 10:21
    
Thanks for pointing me to the right direction, I was really wrong here. –  Chorochrondochor May 15 '14 at 11:18

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.