Порівняйте об'єкти Date з різними рівнями точності

У мене є тест JUnit, який не вдається, оскільки мілісекунди відрізняються. У цьому випадку мене не хвилюють мілісекунди. Як я можу змінити точність твердження, щоб ігнорувати мілісекунди (або будь-яку точність, яку я хотів би встановити)?

Приклад невдалого твердження, яке я хотів би передати:

Date dateOne = new Date();
dateOne.setTime(61202516585000L);
Date dateTwo = new Date();
dateTwo.setTime(61202516585123L);
assertEquals(dateOne, dateTwo);

Використовуйте DateFormatоб’єкт у форматі, який показує лише ті частини, яким ви хочете збігатися, і виконуйте assertEquals()на отриманих рядках. Ви також можете легко обернути це своїм assertDatesAlmostEqual()методом.

Ще одне обхідне рішення, я б зробив це так:

assertTrue("Dates aren't close enough to each other!", (date2.getTime() - date1.getTime()) < 1000);

Є бібліотеки, які допомагають у цьому:

Apache commons-lang

Якщо у вас є Apache commons-lang на вашому шляху DateUtils.truncateдо класу , ви можете використати для усічення дат у якомусь полі.

assertEquals(DateUtils.truncate(date1,Calendar.SECOND),
             DateUtils.truncate(date2,Calendar.SECOND));

Для цього є скорочення:

assertTrue(DateUtils.truncatedEquals(date1,date2,Calendar.SECOND));

Зверніть увагу, що 12: 00: 00.001 та 11: 59: 00.999 будуть усікатися до різних значень, тому це може бути не ідеальним. Для цього є круглий:

assertEquals(DateUtils.round(date1,Calendar.SECOND),
             DateUtils.round(date2,Calendar.SECOND));

AssertJ

Починаючи з версії 3.7.0, AssertJ додав isCloseToтвердження, якщо ви використовуєте Java 8 Date / Time API.

LocalTime _07_10 = LocalTime.of(7, 10);
LocalTime _07_42 = LocalTime.of(7, 42);
assertThat(_07_10).isCloseTo(_07_42, within(1, ChronoUnit.HOURS));
assertThat(_07_10).isCloseTo(_07_42, within(32, ChronoUnit.MINUTES));

Він також працює зі застарілими датами Java:

Date d1 = new Date();
Date d2 = new Date();
assertThat(d1).isCloseTo(d2, within(100, ChronoUnit.MILLIS).getValue());

Ви можете зробити щось подібне:

assertTrue((date1.getTime()/1000) == (date2.getTime()/1000));

Порівняння рядків не потрібно.

У JUnit ви можете запрограмувати два методи затвердження, наприклад:

public class MyTest {
  @Test
  public void test() {
    ...
    assertEqualDates(expectedDateObject, resultDate);

    // somewhat more confortable:
    assertEqualDates("01/01/2012", anotherResultDate);
  }

  private static final String DATE_PATTERN = "dd/MM/yyyy";

  private static void assertEqualDates(String expected, Date value) {
      DateFormat formatter = new SimpleDateFormat(DATE_PATTERN);
      String strValue = formatter.format(value);
      assertEquals(expected, strValue);
  }

  private static void assertEqualDates(Date expected, Date value) {
    DateFormat formatter = new SimpleDateFormat(DATE_PATTERN);
    String strExpected = formatter.format(expected);
    String strValue = formatter.format(value);
    assertEquals(strExpected, strValue);
  }
}

Я не знаю, чи є підтримка в JUnit, але один із способів це зробити:

import java.text.SimpleDateFormat;
import java.util.Date;

public class Example {

    private static SimpleDateFormat formatter = new SimpleDateFormat("dd MMM yyyy HH:mm:ss");

    private static boolean assertEqualDates(Date date1, Date date2) {
        String d1 = formatter.format(date1);            
        String d2 = formatter.format(date2);            
        return d1.equals(d2);
    }    

    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date();

        if (assertEqualDates(date1,date2)) { System.out.println("true!"); }
    }
}

Це насправді складніша проблема, ніж представляється через граничні випадки, коли дисперсія, про яку ви не дбаєте, перетинає поріг для значення, яке ви перевіряєте. наприклад, різниця в мілісекундах менше секунди, але дві позначки часу перетинають другий поріг, або хвилину, або годину. Це робить будь-який підхід DateFormat по своїй суті схильним до помилок.

Натомість я б запропонував порівняти фактичні позначки часу в мілісекундах та надати дельту дисперсії, яка вказує, яку ви вважаєте допустимою різницею між двома об’єктами дати. Наводиться надто багатослівний приклад:

public static void assertDateSimilar(Date expected, Date actual, long allowableVariance)
{
    long variance = Math.abs(allowableVariance);

    long millis = expected.getTime();
    long lowerBound = millis - allowableVariance;
    long upperBound = millis + allowableVariance;

    DateFormat df = DateFormat.getDateTimeInstance();

    boolean within = lowerBound <= actual.getTime() && actual.getTime() <= upperBound;
    assertTrue(MessageFormat.format("Expected {0} with variance of {1} but received {2}", df.format(expected), allowableVariance, df.format(actual)), within);
}

Використовуючи JUnit 4, ви також можете застосувати збіжник для тестування дат відповідно до обраної вами точності. У цьому прикладі збіжник приймає як параметр вираз формату рядка. Код для цього прикладу не є коротшим. Однак клас зіставлення може бути використаний повторно; і якщо ви дасте йому описуючу назву, ви можете елегантно задокументувати намір за допомогою тесту.

import static org.junit.Assert.assertThat;
// further imports from org.junit. and org.hamcrest.

@Test
public void testAddEventsToBaby() {
    Date referenceDate = new Date();
    // Do something..
    Date testDate = new Date();

    //assertThat(referenceDate, equalTo(testDate)); // Test on equal could fail; it is a race condition
    assertThat(referenceDate, sameCalendarDay(testDate, "yyyy MM dd"));
}

public static Matcher<Date> sameCalendarDay(final Object testValue, final String dateFormat){

    final SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);

    return new BaseMatcher<Date>() {

        protected Object theTestValue = testValue;


        public boolean matches(Object theExpected) {
            return formatter.format(theExpected).equals(formatter.format(theTestValue));
        }

        public void describeTo(Description description) {
            description.appendText(theTestValue.toString());
        }
    };
}

використовувати твердження AssertJ для Joda-Time ( http://joel-costigliola.github.io/assertj/assertj-joda-time.html )

import static org.assertj.jodatime.api.Assertions.assertThat;
import org.joda.time.DateTime;

assertThat(new DateTime(dateOne.getTime())).isEqualToIgnoringMillis(new DateTime(dateTwo.getTime()));

повідомлення про невдалий тест є більш читабельним

java.lang.AssertionError: 
Expecting:
  <2014-07-28T08:00:00.000+08:00>
to have same year, month, day, hour, minute and second as:
  <2014-07-28T08:10:00.000+08:00>
but had not.

Якби ви використовували Joda, ви могли б використовувати Fest Joda Time .

Просто порівняйте частини дати, які вас цікавлять для порівняння:

Date dateOne = new Date();
dateOne.setTime(61202516585000L);
Date dateTwo = new Date();
dateTwo.setTime(61202516585123L);

assertEquals(dateOne.getMonth(), dateTwo.getMonth());
assertEquals(dateOne.getDate(), dateTwo.getDate());
assertEquals(dateOne.getYear(), dateTwo.getYear());

// alternative to testing with deprecated methods in Date class
Calendar calOne = Calendar.getInstance();
Calendar calTwo = Calendar.getInstance();
calOne.setTime(dateOne);
calTwo.setTime(dateTwo);

assertEquals(calOne.get(Calendar.MONTH), calTwo.get(Calendar.MONTH));
assertEquals(calOne.get(Calendar.DATE), calTwo.get(Calendar.DATE));
assertEquals(calOne.get(Calendar.YEAR), calTwo.get(Calendar.YEAR));

JUnit має вбудоване твердження для порівняння подвійних та уточнення того, наскільки вони повинні бути близькими. У цьому випадку дельта знаходиться в межах того, скільки мілісекунд ви вважаєте датами еквівалентними. Це рішення не має граничних умов, вимірює абсолютну дисперсію, може легко визначити точність і не вимагає написання додаткових бібліотек або коду.

    Date dateOne = new Date();
    dateOne.setTime(61202516585000L);
    Date dateTwo = new Date();
    dateTwo.setTime(61202516585123L);
    // this line passes correctly 
    Assert.assertEquals(dateOne.getTime(), dateTwo.getTime(), 500.0);
    // this line fails correctly
    Assert.assertEquals(dateOne.getTime(), dateTwo.getTime(), 100.0);

Примітка. Це повинно бути 100,0 замість 100 (або потрібно кидок для подвоєння), щоб змусити його порівнювати їх як подвійні.

Ви можете вибрати рівень точності для порівняння дат, наприклад:

LocalDateTime now = LocalDateTime.now().truncatedTo(ChronoUnit.SECONDS);
// e.g. in MySQL db "timestamp" is without fractional seconds precision (just up to seconds precision)
assertEquals(myTimestamp, now);

Щось подібне може спрацювати:

assertEquals(new SimpleDateFormat("dd MMM yyyy").format(dateOne),
                   new SimpleDateFormat("dd MMM yyyy").format(dateTwo));

Замість того, щоб використовувати new Dateбезпосередньо, ви можете створити невеликого співавтора, з якого ви можете висміятись у своєму тесті:

public class DateBuilder {
    public java.util.Date now() {
        return new java.util.Date();
    }
}

Створіть учасника DateBuilder і змініть виклики з new DateнаdateBuilder.now()

import java.util.Date;

public class Demo {

    DateBuilder dateBuilder = new DateBuilder();

    public void run() throws InterruptedException {
        Date dateOne = dateBuilder.now();
        Thread.sleep(10);
        Date dateTwo = dateBuilder.now();
        System.out.println("Dates are the same: " + dateOne.equals(dateTwo));
    }

    public static void main(String[] args) throws InterruptedException {
        new Demo().run();
    }
}

Основний метод дозволить отримати:

Dates are the same: false

У тесті ви можете ввести заглушку DateBuilderта дозволити їй повернути будь-яке значення, яке вам подобається. Наприклад, з Mockito або анонімним класом, який замінює now():

public class DemoTest {

    @org.junit.Test
    public void testMockito() throws Exception {
        DateBuilder stub = org.mockito.Mockito.mock(DateBuilder.class);
        org.mockito.Mockito.when(stub.now()).thenReturn(new java.util.Date(42));

        Demo demo = new Demo();
        demo.dateBuilder = stub;
        demo.run();
    }

    @org.junit.Test
    public void testAnonymousClass() throws Exception {
        Demo demo = new Demo();
        demo.dateBuilder = new DateBuilder() {
            @Override
            public Date now() {
                return new Date(42);
            }
        };
        demo.run();
    }
}

Перетворіть дати в String за допомогою SimpleDateFromat, вкажіть у конструкторі необхідні поля дати / часу та порівняйте значення рядків:

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String expectedDate = formatter.format(dateOne));
String dateToTest = formatter.format(dateTwo);
assertEquals(expectedDate, dateToTest);

Я провів невеликий клас, який може бути корисним для деяких користувачів Google, які опиняються тут: https://stackoverflow.com/a/37168645/5930242

Ось функція утиліти, яка зробила цю роботу за мене.

    private boolean isEqual(Date d1, Date d2){
        return d1.toLocalDate().equals(d2.toLocalDate());
    }

я перекидаю об'єкти на java.util.Date і порівнюю

assertEquals((Date)timestamp1,(Date)timestamp2);