Clockoffset now shifts, by tenant, the time at which beats are published.
diff --git a/component-test/src/main/java/io/mifos/rhythm/AbstractRhythmTest.java b/component-test/src/main/java/io/mifos/rhythm/AbstractRhythmTest.java
index f3c3f1b..763e832 100644
--- a/component-test/src/main/java/io/mifos/rhythm/AbstractRhythmTest.java
+++ b/component-test/src/main/java/io/mifos/rhythm/AbstractRhythmTest.java
@@ -25,6 +25,7 @@
import io.mifos.core.test.listener.EventRecorder;
import io.mifos.rhythm.api.v1.client.RhythmManager;
import io.mifos.rhythm.api.v1.domain.Beat;
+import io.mifos.rhythm.api.v1.domain.ClockOffset;
import io.mifos.rhythm.api.v1.events.BeatEvent;
import io.mifos.rhythm.api.v1.events.EventConstants;
import io.mifos.rhythm.service.config.RhythmConfiguration;
@@ -68,7 +69,7 @@
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT,
classes = {AbstractRhythmTest.TestConfiguration.class},
- properties = {"rhythm.user=homer", "rhythm.beatCheckRate=500"}
+ properties = {"rhythm.user=homer", "rhythm.beatCheckRate=1000"}
)
public class AbstractRhythmTest {
@@ -205,11 +206,20 @@
}
LocalDateTime getExpectedBeatTimestamp(final LocalDateTime fromTime, final Integer alignmentHour) {
+ return getExpectedBeatTimestamp(fromTime, alignmentHour, new ClockOffset());
+ }
+
+ LocalDateTime getExpectedBeatTimestamp(
+ final LocalDateTime fromTime,
+ final Integer alignmentHour,
+ final ClockOffset clockOffset) {
final LocalDateTime midnight = fromTime.truncatedTo(ChronoUnit.DAYS);
- return midnight.plusHours(alignmentHour);
+ return midnight.plusHours(alignmentHour + clockOffset.getHours())
+ .plusMinutes(clockOffset.getMinutes())
+ .plusSeconds(clockOffset.getSeconds());
}
private LocalDateTime getNextTimeStamp(final LocalDateTime fromTime) {
return fromTime.plusDays(1);
}
-}
+}
\ No newline at end of file
diff --git a/component-test/src/main/java/io/mifos/rhythm/TestBeats.java b/component-test/src/main/java/io/mifos/rhythm/TestBeats.java
index b3890a9..b420574 100644
--- a/component-test/src/main/java/io/mifos/rhythm/TestBeats.java
+++ b/component-test/src/main/java/io/mifos/rhythm/TestBeats.java
@@ -133,7 +133,30 @@
}
@Test
- public void shouldChangeTheTenantClockOffset() throws InterruptedException {
+ public void shouldBeatForMissingDays() throws InterruptedException {
+ final String applicationIdentifier = "funnybusiness-v6";
+ final String beatIdentifier = "fiddlebeat";
+ createBeatForThisHour(applicationIdentifier, beatIdentifier);
+
+ final int daysAgo = 10;
+ final LocalDateTime nextBeat = setBack(applicationIdentifier, beatIdentifier, daysAgo);
+
+ for (int i = daysAgo; i > 0; i--) {
+ Mockito.verify(beatPublisherServiceMock, Mockito.timeout(4_000).times(1))
+ .publishBeat(
+ beatIdentifier,
+ tenantDataStoreContext.getTenantName(),
+ applicationIdentifier,
+ nextBeat.minusDays(daysAgo));
+ }
+ }
+
+ @Test
+ public void clockOffsetShouldEffectBeatTiming() throws InterruptedException {
+ final String tenantIdentifier = tenantDataStoreContext.getTenantName();
+ final String applicationIdentifier = "funnybusiness-v7";
+ final String beatIdentifier = "fiddlebeat0";
+
final ClockOffset initialClockOffset = this.testSubject.getClockOffset();
Assert.assertEquals(Integer.valueOf(0), initialClockOffset.getHours());
Assert.assertEquals(Integer.valueOf(0), initialClockOffset.getMinutes());
@@ -147,21 +170,27 @@
final ClockOffset changedClockOffset = this.testSubject.getClockOffset();
Assert.assertEquals(offsetToNow, changedClockOffset);
- }
- @Test
- public void shouldBeatForMissingDays() throws InterruptedException {
- final String applicationIdentifier = "funnybusiness-v6";
- final String beatIdentifier = "fiddlebeat";
- createBeatForThisHour(applicationIdentifier, beatIdentifier);
+ final Beat beat = new Beat();
+ beat.setIdentifier(beatIdentifier);
+ beat.setAlignmentHour(0);
- final int daysAgo = 10;
- final LocalDateTime nextBeat = setBack(applicationIdentifier, beatIdentifier, daysAgo);
+ final LocalDateTime expectedBeatTimestamp = getExpectedBeatTimestamp(now, 0, offsetToNow);
- for (int i = daysAgo; i > 0; i--) {
- Mockito.verify(beatPublisherServiceMock, Mockito.timeout(4_000).times(1))
- .publishBeat(beatIdentifier, tenantDataStoreContext.getTenantName(), applicationIdentifier, nextBeat.minusDays(daysAgo));
- }
+ Mockito.doReturn(Optional.of("boop")).when(beatPublisherServiceMock)
+ .requestPermissionForBeats(Matchers.eq(tenantIdentifier), Matchers.eq(applicationIdentifier));
+ Mockito.when(beatPublisherServiceMock
+ .publishBeat(beatIdentifier, tenantIdentifier, applicationIdentifier, expectedBeatTimestamp))
+ .thenReturn(true);
+
+ this.testSubject.createBeat(applicationIdentifier, beat);
+
+ Assert.assertTrue(this.eventRecorder.wait(EventConstants.POST_BEAT, new BeatEvent(applicationIdentifier, beat.getIdentifier())));
+
+ Mockito.verify(beatPublisherServiceMock, Mockito.timeout(10_000).times(1)).publishBeat(beatIdentifier, tenantIdentifier, applicationIdentifier, expectedBeatTimestamp);
+
+ this.testSubject.setClockOffset(initialClockOffset);
+ Assert.assertTrue(this.eventRecorder.wait(EventConstants.PUT_CLOCKOFFSET, initialClockOffset));
}
@Transactional
diff --git a/service/src/main/java/io/mifos/rhythm/service/internal/command/handler/BeatCommandHandler.java b/service/src/main/java/io/mifos/rhythm/service/internal/command/handler/BeatCommandHandler.java
index a59c0ee..922d831 100644
--- a/service/src/main/java/io/mifos/rhythm/service/internal/command/handler/BeatCommandHandler.java
+++ b/service/src/main/java/io/mifos/rhythm/service/internal/command/handler/BeatCommandHandler.java
@@ -18,6 +18,7 @@
import io.mifos.core.command.annotation.Aggregate;
import io.mifos.core.command.annotation.CommandHandler;
import io.mifos.core.command.annotation.CommandLogLevel;
+import io.mifos.rhythm.api.v1.domain.ClockOffset;
import io.mifos.rhythm.api.v1.events.BeatEvent;
import io.mifos.rhythm.api.v1.events.EventConstants;
import io.mifos.rhythm.service.ServiceConstants;
@@ -26,6 +27,7 @@
import io.mifos.rhythm.service.internal.mapper.BeatMapper;
import io.mifos.rhythm.service.internal.repository.BeatEntity;
import io.mifos.rhythm.service.internal.repository.BeatRepository;
+import io.mifos.rhythm.service.internal.service.ClockOffsetService;
import io.mifos.rhythm.service.internal.service.IdentityPermittableGroupService;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
@@ -40,18 +42,21 @@
public class BeatCommandHandler {
private final IdentityPermittableGroupService identityPermittableGroupService;
private final BeatRepository beatRepository;
+ private final ClockOffsetService clockOffsetService;
private final EventHelper eventHelper;
private final Logger logger;
@Autowired
public BeatCommandHandler(
- final IdentityPermittableGroupService identityPermittableGroupService,
- final BeatRepository beatRepository,
- final EventHelper eventHelper,
- @Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger) {
+ final IdentityPermittableGroupService identityPermittableGroupService,
+ final BeatRepository beatRepository,
+ final ClockOffsetService clockOffsetService,
+ final EventHelper eventHelper,
+ @Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger) {
super();
this.identityPermittableGroupService = identityPermittableGroupService;
this.beatRepository = beatRepository;
+ this.clockOffsetService = clockOffsetService;
this.eventHelper = eventHelper;
this.logger = logger;
}
@@ -70,18 +75,20 @@
//stuff that should happen in the transaction.
@SuppressWarnings("WeakerAccess")
@Transactional
- public void processCreateBeatCommand(CreateBeatCommand createBeatCommand) {
+ public void processCreateBeatCommand(final CreateBeatCommand createBeatCommand) {
final boolean applicationHasRequestForAccessPermission = identityPermittableGroupService.checkThatApplicationHasRequestForAccessPermission(
- createBeatCommand.getTenantIdentifier(), createBeatCommand.getApplicationIdentifier());
+ createBeatCommand.getTenantIdentifier(), createBeatCommand.getApplicationIdentifier());
if (!applicationHasRequestForAccessPermission) {
logger.info("Rhythm needs permission to publish beats to application, but couldn't request that permission for tenant '{}' and application '{}'.",
- createBeatCommand.getTenantIdentifier(), createBeatCommand.getApplicationIdentifier());
+ createBeatCommand.getTenantIdentifier(), createBeatCommand.getApplicationIdentifier());
}
+ final ClockOffset clockOffset = clockOffsetService.findByTenantIdentifier(createBeatCommand.getTenantIdentifier());
final BeatEntity entity = BeatMapper.map(
- createBeatCommand.getTenantIdentifier(),
- createBeatCommand.getApplicationIdentifier(),
- createBeatCommand.getInstance());
+ createBeatCommand.getTenantIdentifier(),
+ createBeatCommand.getApplicationIdentifier(),
+ createBeatCommand.getInstance(),
+ clockOffset);
this.beatRepository.save(entity);
}
diff --git a/service/src/main/java/io/mifos/rhythm/service/internal/mapper/BeatMapper.java b/service/src/main/java/io/mifos/rhythm/service/internal/mapper/BeatMapper.java
index 2f37f95..5ae4aac 100644
--- a/service/src/main/java/io/mifos/rhythm/service/internal/mapper/BeatMapper.java
+++ b/service/src/main/java/io/mifos/rhythm/service/internal/mapper/BeatMapper.java
@@ -16,10 +16,11 @@
package io.mifos.rhythm.service.internal.mapper;
import io.mifos.rhythm.api.v1.domain.Beat;
+import io.mifos.rhythm.api.v1.domain.ClockOffset;
import io.mifos.rhythm.service.internal.repository.BeatEntity;
+import java.time.Clock;
import java.time.LocalDateTime;
-import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
@@ -42,14 +43,22 @@
return ret;
}
- static BeatEntity map(final String tenantIdentifier, final String applicationIdentifier, final Beat instance) {
+ static BeatEntity map(
+ final String tenantIdentifier,
+ final String applicationIdentifier,
+ final Beat instance,
+ final ClockOffset offset) {
final BeatEntity ret = new BeatEntity();
ret.setBeatIdentifier(instance.getIdentifier());
ret.setTenantIdentifier(tenantIdentifier);
ret.setApplicationIdentifier(applicationIdentifier);
ret.setAlignmentHour(instance.getAlignmentHour());
- //First beat is today. If it's in the past, it will be created nearly immediately.
- ret.setNextBeat(LocalDateTime.now(ZoneId.of("UTC")).truncatedTo(ChronoUnit.DAYS).plusHours(instance.getAlignmentHour()));
+ //First beat is today. If it's in the past, it will be published nearly immediately.
+ ret.setNextBeat(LocalDateTime.now(Clock.systemUTC())
+ .truncatedTo(ChronoUnit.DAYS)
+ .plusHours(instance.getAlignmentHour() + offset.getHours())
+ .plusMinutes(offset.getMinutes())
+ .plusSeconds(offset.getSeconds()));
return ret;
}
}
diff --git a/service/src/main/java/io/mifos/rhythm/service/internal/service/ClockOffsetService.java b/service/src/main/java/io/mifos/rhythm/service/internal/service/ClockOffsetService.java
index 07c17e0..1700f5a 100644
--- a/service/src/main/java/io/mifos/rhythm/service/internal/service/ClockOffsetService.java
+++ b/service/src/main/java/io/mifos/rhythm/service/internal/service/ClockOffsetService.java
@@ -33,9 +33,9 @@
this.clockOffsetRepository = clockOffsetRepository;
}
- public ClockOffset findByTenant(final String tenantIdentifier) {
+ public ClockOffset findByTenantIdentifier(final String tenantIdentifier) {
return clockOffsetRepository.findByTenantIdentifier(tenantIdentifier)
.map(ClockOffsetMapper::map)
- .orElseGet(ClockOffset::new);
+ .orElseGet(ClockOffset::new); //If none is set, use 0,0,0
}
}
\ No newline at end of file
diff --git a/service/src/main/java/io/mifos/rhythm/service/internal/service/Drummer.java b/service/src/main/java/io/mifos/rhythm/service/internal/service/Drummer.java
index e0851cd..d3bf08c 100644
--- a/service/src/main/java/io/mifos/rhythm/service/internal/service/Drummer.java
+++ b/service/src/main/java/io/mifos/rhythm/service/internal/service/Drummer.java
@@ -15,6 +15,7 @@
*/
package io.mifos.rhythm.service.internal.service;
+import io.mifos.rhythm.api.v1.domain.ClockOffset;
import io.mifos.rhythm.service.ServiceConstants;
import io.mifos.rhythm.service.internal.repository.BeatEntity;
import io.mifos.rhythm.service.internal.repository.BeatRepository;
@@ -27,8 +28,8 @@
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Nonnull;
+import java.time.Clock;
import java.time.LocalDateTime;
-import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.Optional;
import java.util.function.Predicate;
@@ -37,12 +38,12 @@
/**
* @author Myrle Krantz
*/
-@SuppressWarnings({"unused", "WeakerAccess"})
@Component
public class Drummer {
private final IdentityPermittableGroupService identityPermittableGroupService;
private final BeatPublisherService beatPublisherService;
private final BeatRepository beatRepository;
+ private final ClockOffsetService clockOffsetService;
private final Logger logger;
@Autowired
@@ -50,10 +51,12 @@
final IdentityPermittableGroupService identityPermittableGroupService,
final BeatPublisherService beatPublisherService,
final BeatRepository beatRepository,
+ final ClockOffsetService clockOffsetService,
@Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger) {
this.identityPermittableGroupService = identityPermittableGroupService;
this.beatPublisherService = beatPublisherService;
this.beatRepository = beatRepository;
+ this.clockOffsetService = clockOffsetService;
this.logger = logger;
}
@@ -63,7 +66,7 @@
//In it's current form this function cannot be run in multiple instances of the same service. We need to get
//locking on selected entries corrected here, before this will work.
try {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
//Get beats from the last two hours in case restart/start happens close to hour begin.
final Stream<BeatEntity> beats = beatRepository.findByNextBeatBefore(now);
beats.forEach((beat) -> {
@@ -86,6 +89,7 @@
beat.setNextBeat(y);
beatRepository.save(beat);
});
+ logger.info("Beat updated to {}.", beat);
}
});
@@ -96,14 +100,15 @@
}
}
- public Optional<LocalDateTime> checkBeatForPublish(
- final LocalDateTime now,
- final String beatIdentifier,
- final String tenantIdentifier,
- final String applicationIdentifier,
- final Integer alignmentHour,
- final LocalDateTime nextBeat) {
- return checkBeatForPublishHelper(now, alignmentHour, nextBeat,
+ private Optional<LocalDateTime> checkBeatForPublish(
+ final LocalDateTime now,
+ final String beatIdentifier,
+ final String tenantIdentifier,
+ final String applicationIdentifier,
+ final Integer alignmentHour,
+ final LocalDateTime nextBeat) {
+ final ClockOffset clockOffset = clockOffsetService.findByTenantIdentifier(tenantIdentifier);
+ return checkBeatForPublishHelper(now, alignmentHour, nextBeat, clockOffset,
x -> beatPublisherService.publishBeat(beatIdentifier, tenantIdentifier, applicationIdentifier, x));
}
@@ -112,13 +117,14 @@
final LocalDateTime now,
final Integer alignmentHour,
final LocalDateTime nextBeat,
+ final ClockOffset clockOffset,
final Predicate<LocalDateTime> publishSucceeded) {
final long numberOfBeatPublishesNeeded = getNumberOfBeatPublishesNeeded(now, nextBeat);
if (numberOfBeatPublishesNeeded == 0)
return Optional.empty();
final Optional<LocalDateTime> firstFailedBeat = Stream.iterate(nextBeat,
- x -> incrementToAlignment(x, alignmentHour))
+ x -> incrementToAlignment(x, alignmentHour, clockOffset))
.limit(numberOfBeatPublishesNeeded)
.filter(x -> !publishSucceeded.test(x))
.findFirst();
@@ -126,7 +132,7 @@
if (firstFailedBeat.isPresent())
return firstFailedBeat;
else
- return Optional.of(incrementToAlignment(now, alignmentHour));
+ return Optional.of(incrementToAlignment(now, alignmentHour, clockOffset));
}
static long getNumberOfBeatPublishesNeeded(final LocalDateTime now, final @Nonnull LocalDateTime nextBeat) {
@@ -136,8 +142,15 @@
return Math.max(1, nextBeat.until(now, ChronoUnit.DAYS));
}
- static LocalDateTime incrementToAlignment(final LocalDateTime toIncrement, final Integer alignmentHour)
+ static LocalDateTime incrementToAlignment(
+ final LocalDateTime toIncrement,
+ final Integer alignmentHour,
+ final ClockOffset clockOffset)
{
- return toIncrement.plusDays(1).truncatedTo(ChronoUnit.DAYS).plusHours(alignmentHour);
+ return toIncrement.truncatedTo(ChronoUnit.DAYS)
+ .plusDays(1)
+ .plusHours(alignmentHour + clockOffset.getHours())
+ .plusMinutes(clockOffset.getMinutes())
+ .plusSeconds(clockOffset.getSeconds());
}
}
\ No newline at end of file
diff --git a/service/src/main/java/io/mifos/rhythm/service/rest/ClockOffsetRestController.java b/service/src/main/java/io/mifos/rhythm/service/rest/ClockOffsetRestController.java
index a788d28..9793731 100644
--- a/service/src/main/java/io/mifos/rhythm/service/rest/ClockOffsetRestController.java
+++ b/service/src/main/java/io/mifos/rhythm/service/rest/ClockOffsetRestController.java
@@ -57,7 +57,7 @@
public
@ResponseBody
ResponseEntity<ClockOffset> getClockOffset(@RequestHeader(TENANT_HEADER) final String tenantIdentifier) {
- return ResponseEntity.ok(this.clockOffsetService.findByTenant(tenantIdentifier));
+ return ResponseEntity.ok(this.clockOffsetService.findByTenantIdentifier(tenantIdentifier));
}
@Permittable(value = AcceptedTokenType.SYSTEM)
diff --git a/service/src/test/java/io/mifos/rhythm/service/internal/service/DrummerTest.java b/service/src/test/java/io/mifos/rhythm/service/internal/service/DrummerTest.java
index 3cb376d..4c45010 100644
--- a/service/src/test/java/io/mifos/rhythm/service/internal/service/DrummerTest.java
+++ b/service/src/test/java/io/mifos/rhythm/service/internal/service/DrummerTest.java
@@ -15,14 +15,17 @@
*/
package io.mifos.rhythm.service.internal.service;
+import io.mifos.rhythm.api.v1.domain.ClockOffset;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
+import java.time.Clock;
import java.time.LocalDateTime;
-import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
+import java.util.HashSet;
import java.util.Optional;
+import java.util.Set;
import java.util.function.Predicate;
/**
@@ -32,8 +35,8 @@
@Test
public void incrementToAlignment() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
- final LocalDateTime tomorrow = Drummer.incrementToAlignment(now, 3);
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
+ final LocalDateTime tomorrow = Drummer.incrementToAlignment(now, 3, new ClockOffset());
Assert.assertEquals(tomorrow.minusDays(1).truncatedTo(ChronoUnit.DAYS), now.truncatedTo(ChronoUnit.DAYS));
Assert.assertEquals(3, tomorrow.getHour());
@@ -41,7 +44,7 @@
@Test
public void getNumberOfBeatPublishesNeeded() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
final long eventsNeeded3 = Drummer.getNumberOfBeatPublishesNeeded(now, now.minus(3, ChronoUnit.DAYS));
Assert.assertEquals(3, eventsNeeded3);
@@ -54,38 +57,62 @@
@Test
public void checkBeatForPublishAllBeatsSucceed() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
- final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(now, 0, now.minus(3, ChronoUnit.DAYS), x -> true);
- Assert.assertEquals(Optional.of(Drummer.incrementToAlignment(now, 0)), ret);
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
+ final Set<LocalDateTime> calledForTimes = new HashSet<>();
+ final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(
+ now,
+ 0,
+ now.minus(3, ChronoUnit.DAYS),
+ new ClockOffset(),
+ x -> {
+ calledForTimes.add(x);
+ return true;
+ });
+ Assert.assertEquals(Optional.of(Drummer.incrementToAlignment(now, 0, new ClockOffset())), ret);
+ Assert.assertEquals(3, calledForTimes.size());
}
@Test
public void checkBeatForPublishFirstFails() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
final LocalDateTime nextBeat = now.minus(3, ChronoUnit.DAYS);
@SuppressWarnings("unchecked") final Predicate<LocalDateTime> produceBeatsMock = Mockito.mock(Predicate.class);
Mockito.when(produceBeatsMock.test(nextBeat)).thenReturn(false);
- final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(now, 0, nextBeat, produceBeatsMock);
+ final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(
+ now,
+ 0,
+ nextBeat,
+ new ClockOffset(),
+ produceBeatsMock);
Assert.assertEquals(Optional.of(nextBeat), ret);
}
@Test
public void checkBeatForPublishSecondFails() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
final LocalDateTime nextBeat = now.minus(3, ChronoUnit.DAYS);
- final LocalDateTime secondBeat = Drummer.incrementToAlignment(nextBeat, 0);
+ final LocalDateTime secondBeat = Drummer.incrementToAlignment(nextBeat, 0, new ClockOffset());
@SuppressWarnings("unchecked") final Predicate<LocalDateTime> produceBeatsMock = Mockito.mock(Predicate.class);
Mockito.when(produceBeatsMock.test(nextBeat)).thenReturn(true);
Mockito.when(produceBeatsMock.test(secondBeat)).thenReturn(false);
- final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(now, 0, nextBeat, produceBeatsMock);
+ final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(
+ now,
+ 0,
+ nextBeat,
+ new ClockOffset(),
+ produceBeatsMock);
Assert.assertEquals(Optional.of(secondBeat), ret);
}
@Test
public void checkBeatForPublishNoneNeeded() {
- final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC"));
- final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(now, 0, now.plus(1, ChronoUnit.DAYS),
- x -> { Assert.fail("Pubish shouldn't be called"); return true; });
+ final LocalDateTime now = LocalDateTime.now(Clock.systemUTC());
+ final Optional<LocalDateTime> ret = Drummer.checkBeatForPublishHelper(
+ now,
+ 0,
+ now.plus(1, ChronoUnit.DAYS),
+ new ClockOffset(),
+ x -> { Assert.fail("Publish shouldn't be called"); return true; });
Assert.assertEquals(Optional.empty(), ret);
}
}
\ No newline at end of file
