Merge e43e8c4 into 0e8bbcc

CJSCommonPlatform · Jan 21, 2020 · 59872ae · 59872ae
2 parents 0e8bbcc + e43e8c4
commit 59872ae
Show file tree

Hide file tree

Showing 8 changed files with 173 additions and 7 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,11 +5,12 @@ on [Keep a CHANGELOG](http://keepachangelog.com/). This project adheres to
 
 ## [Unreleased]
 
-### Fixed
-- Fixed catchup error where catchup was marked as complete after all subscriptions rather than all components
-
+## [2.4.6] - 2020-01-21
 ### Added
+- Catchup for multiple components now run in order of component and subscription priority
 - Added event source name to catchup logger output
+### Fixed
+- Fixed catchup error where catchup was marked as complete after all subscriptions rather than all components
 
 ## [2.4.5] - 2020-01-06
 ### Removed

diff --git a/...ava/uk/gov/justice/services/eventstore/management/catchup/process/EventCatchupRunner.java b/...ava/uk/gov/justice/services/eventstore/management/catchup/process/EventCatchupRunner.java
@@ -36,7 +36,8 @@ public void runEventCatchup(final UUID commandId, final CatchupCommand catchupCo
                 clock.now()
         ));
 
-        subscriptionCatchupDefinitions.forEach(catchupFor -> eventCatchupByComponentRunner.runEventCatchupForComponent(
+        subscriptionCatchupDefinitions
+                .forEach(catchupFor -> eventCatchupByComponentRunner.runEventCatchupForComponent(
                 catchupFor,
                 commandId,
                 catchupCommand));

diff --git a/...ov/justice/services/eventstore/management/catchup/process/PriorityComparatorProvider.java b/...ov/justice/services/eventstore/management/catchup/process/PriorityComparatorProvider.java
@@ -0,0 +1,19 @@
+package uk.gov.justice.services.eventstore.management.catchup.process;
+
+import static java.util.Comparator.comparingInt;
+
+import uk.gov.justice.subscription.domain.subscriptiondescriptor.Subscription;
+import uk.gov.justice.subscription.domain.subscriptiondescriptor.SubscriptionsDescriptor;
+
+import java.util.Comparator;
+
+public class PriorityComparatorProvider {
+
+    public Comparator<SubscriptionsDescriptor> getSubscriptionDescriptorComparator() {
+        return comparingInt(SubscriptionsDescriptor::getPrioritisation);
+    }
+
+    public Comparator<Subscription> getSubscriptionComparator() {
+        return comparingInt(Subscription::getPrioritisation);
+    }
+}
diff --git a/...tice/services/eventstore/management/catchup/process/SubscriptionCatchupDetailsMapper.java b/...tice/services/eventstore/management/catchup/process/SubscriptionCatchupDetailsMapper.java
@@ -5,14 +5,20 @@
 
 import java.util.stream.Stream;
 
+import javax.inject.Inject;
+
 public class SubscriptionCatchupDetailsMapper {
 
+    @Inject
+    private PriorityComparatorProvider priorityComparatorProvider;
+
     public Stream<SubscriptionCatchupDetails> toSubscriptionCatchupDetails(final SubscriptionsDescriptor subscriptionsDescriptor) {
 
         final String componentName = subscriptionsDescriptor.getServiceComponent();
 
         return subscriptionsDescriptor.getSubscriptions()
                 .stream()
+                .sorted(priorityComparatorProvider.getSubscriptionComparator())
                 .map(subscription ->
                         new SubscriptionCatchupDetails(
                                 subscription.getName(),

diff --git a/...v/justice/services/eventstore/management/catchup/process/SubscriptionCatchupProvider.java b/...v/justice/services/eventstore/management/catchup/process/SubscriptionCatchupProvider.java
@@ -15,6 +15,9 @@ public class SubscriptionCatchupProvider {
     @Inject
     private SubscriptionsDescriptorsRegistry subscriptionsDescriptorsRegistry;
 
+    @Inject
+    private PriorityComparatorProvider priorityComparatorProvider;
+
     @Inject
     private CanCatchupFilter canCatchupFilter;
 
@@ -27,6 +30,7 @@ public List<SubscriptionCatchupDetails> getBySubscription(final CatchupCommand c
                 .getAll()
                 .stream()
                 .filter(subscriptionsDescriptor -> canCatchupFilter.canCatchup(subscriptionsDescriptor, catchupCommand))
+                .sorted(priorityComparatorProvider.getSubscriptionDescriptorComparator())
                 .flatMap(subscriptionCatchupDetailsMapper::toSubscriptionCatchupDetails)
                 .collect(toList());
     }

diff --git a/...ustice/services/eventstore/management/catchup/process/PriorityComparatorProviderTest.java b/...ustice/services/eventstore/management/catchup/process/PriorityComparatorProviderTest.java
@@ -0,0 +1,120 @@
+package uk.gov.justice.services.eventstore.management.catchup.process;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import uk.gov.justice.subscription.domain.subscriptiondescriptor.Subscription;
+import uk.gov.justice.subscription.domain.subscriptiondescriptor.SubscriptionsDescriptor;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class PriorityComparatorProviderTest {
+
+    @InjectMocks
+    private PriorityComparatorProvider priorityComparatorProvider;
+
+    @Test
+    public void shouldSortByComponentPriority() throws Exception {
+
+        final SubscriptionsDescriptor subscriptionsDescriptor_1 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_2 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_3 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_4 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_5 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_6 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_7 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_8 = mock(SubscriptionsDescriptor.class);
+        final SubscriptionsDescriptor subscriptionsDescriptor_9 = mock(SubscriptionsDescriptor.class);
+
+        when(subscriptionsDescriptor_1.getPrioritisation()).thenReturn(1);
+        when(subscriptionsDescriptor_2.getPrioritisation()).thenReturn(2);
+        when(subscriptionsDescriptor_3.getPrioritisation()).thenReturn(3);
+        when(subscriptionsDescriptor_4.getPrioritisation()).thenReturn(4);
+        when(subscriptionsDescriptor_5.getPrioritisation()).thenReturn(5);
+        when(subscriptionsDescriptor_6.getPrioritisation()).thenReturn(6);
+        when(subscriptionsDescriptor_7.getPrioritisation()).thenReturn(7);
+        when(subscriptionsDescriptor_8.getPrioritisation()).thenReturn(8);
+        when(subscriptionsDescriptor_9.getPrioritisation()).thenReturn(9);
+
+        final List<SubscriptionsDescriptor> subscriptionsDescriptors = asList(
+                subscriptionsDescriptor_3,
+                subscriptionsDescriptor_8,
+                subscriptionsDescriptor_4,
+                subscriptionsDescriptor_2,
+                subscriptionsDescriptor_9,
+                subscriptionsDescriptor_5,
+                subscriptionsDescriptor_7,
+                subscriptionsDescriptor_6,
+                subscriptionsDescriptor_1
+        );
+
+        subscriptionsDescriptors.sort(priorityComparatorProvider.getSubscriptionDescriptorComparator());
+
+        assertThat(subscriptionsDescriptors.get(0).getPrioritisation(), is(1));
+        assertThat(subscriptionsDescriptors.get(1).getPrioritisation(), is(2));
+        assertThat(subscriptionsDescriptors.get(2).getPrioritisation(), is(3));
+        assertThat(subscriptionsDescriptors.get(3).getPrioritisation(), is(4));
+        assertThat(subscriptionsDescriptors.get(4).getPrioritisation(), is(5));
+        assertThat(subscriptionsDescriptors.get(5).getPrioritisation(), is(6));
+        assertThat(subscriptionsDescriptors.get(6).getPrioritisation(), is(7));
+        assertThat(subscriptionsDescriptors.get(7).getPrioritisation(), is(8));
+        assertThat(subscriptionsDescriptors.get(8).getPrioritisation(), is(9));
+    }
+
+    @Test
+    public void shouldSortBySubscriptionPriority() throws Exception {
+
+        final Subscription subscription_1 = mock(Subscription.class);
+        final Subscription subscription_2 = mock(Subscription.class);
+        final Subscription subscription_3 = mock(Subscription.class);
+        final Subscription subscription_4 = mock(Subscription.class);
+        final Subscription subscription_5 = mock(Subscription.class);
+        final Subscription subscription_6 = mock(Subscription.class);
+        final Subscription subscription_7 = mock(Subscription.class);
+        final Subscription subscription_8 = mock(Subscription.class);
+        final Subscription subscription_9 = mock(Subscription.class);
+
+        when(subscription_1.getPrioritisation()).thenReturn(1);
+        when(subscription_2.getPrioritisation()).thenReturn(2);
+        when(subscription_3.getPrioritisation()).thenReturn(3);
+        when(subscription_4.getPrioritisation()).thenReturn(4);
+        when(subscription_5.getPrioritisation()).thenReturn(5);
+        when(subscription_6.getPrioritisation()).thenReturn(6);
+        when(subscription_7.getPrioritisation()).thenReturn(7);
+        when(subscription_8.getPrioritisation()).thenReturn(8);
+        when(subscription_9.getPrioritisation()).thenReturn(9);
+
+        final List<Subscription> subscriptions = asList(
+                subscription_3,
+                subscription_8,
+                subscription_4,
+                subscription_2,
+                subscription_9,
+                subscription_5,
+                subscription_7,
+                subscription_6,
+                subscription_1
+        );
+
+        subscriptions.sort(priorityComparatorProvider.getSubscriptionComparator());
+
+        assertThat(subscriptions.get(0).getPrioritisation(), is(1));
+        assertThat(subscriptions.get(1).getPrioritisation(), is(2));
+        assertThat(subscriptions.get(2).getPrioritisation(), is(3));
+        assertThat(subscriptions.get(3).getPrioritisation(), is(4));
+        assertThat(subscriptions.get(4).getPrioritisation(), is(5));
+        assertThat(subscriptions.get(5).getPrioritisation(), is(6));
+        assertThat(subscriptions.get(6).getPrioritisation(), is(7));
+        assertThat(subscriptions.get(7).getPrioritisation(), is(8));
+        assertThat(subscriptions.get(8).getPrioritisation(), is(9));
+    }
+}
diff --git a/.../services/eventstore/management/catchup/process/SubscriptionCatchupDetailsMapperTest.java b/.../services/eventstore/management/catchup/process/SubscriptionCatchupDetailsMapperTest.java
@@ -16,11 +16,15 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Spy;
 import org.mockito.runners.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 public class SubscriptionCatchupDetailsMapperTest {
 
+    @Spy
+    private PriorityComparatorProvider priorityComparatorProvider = new PriorityComparatorProvider();
+
     @InjectMocks
     private SubscriptionCatchupDetailsMapper subscriptionCatchupDetailsMapper;
 
@@ -37,8 +41,11 @@ public void shouldGetSubscriptionCatchupDetailsFromSubscriptionsDescriptor() thr
         final Subscription subscription_1 = mock(Subscription.class);
         final Subscription subscription_2 = mock(Subscription.class);
 
+        when(subscription_1.getPrioritisation()).thenReturn(100);
+        when(subscription_2.getPrioritisation()).thenReturn(200);
+
         when(subscriptionsDescriptor.getServiceComponent()).thenReturn(componentName);
-        when(subscriptionsDescriptor.getSubscriptions()).thenReturn(asList(subscription_1, subscription_2));
+        when(subscriptionsDescriptor.getSubscriptions()).thenReturn(asList(subscription_2, subscription_1));
         when(subscription_1.getName()).thenReturn(subscriptionName_1);
         when(subscription_1.getEventSourceName()).thenReturn(eventSourceName_1);
         when(subscription_2.getName()).thenReturn(subscriptionName_2);

diff --git a/...stice/services/eventstore/management/catchup/process/SubscriptionCatchupProviderTest.java b/...stice/services/eventstore/management/catchup/process/SubscriptionCatchupProviderTest.java
@@ -19,6 +19,7 @@
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 import org.mockito.runners.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -30,6 +31,9 @@ public class SubscriptionCatchupProviderTest {
     @Mock
     private CanCatchupFilter canCatchupFilter;
 
+    @Spy
+    private PriorityComparatorProvider priorityComparatorProvider = new PriorityComparatorProvider();
+
     @Mock
     private SubscriptionCatchupDetailsMapper subscriptionCatchupDetailsMapper;
 
@@ -45,15 +49,19 @@ public void shouldFindSubscriptionsToCatchup() throws Exception {
         final SubscriptionsDescriptor subscriptionsDescriptor_2 = mock(SubscriptionsDescriptor.class);
         final SubscriptionsDescriptor subscriptionsDescriptor_3 = mock(SubscriptionsDescriptor.class);
 
+        when(subscriptionsDescriptor_1.getPrioritisation()).thenReturn(20);
+        when(subscriptionsDescriptor_2.getPrioritisation()).thenReturn(40);
+        when(subscriptionsDescriptor_3.getPrioritisation()).thenReturn(60);
+
         final SubscriptionCatchupDetails subscriptionCatchupDetails_1_1 = mock(SubscriptionCatchupDetails.class);
         final SubscriptionCatchupDetails subscriptionCatchupDetails_1_2 = mock(SubscriptionCatchupDetails.class);
         final SubscriptionCatchupDetails subscriptionCatchupDetails_3_1 = mock(SubscriptionCatchupDetails.class);
         final SubscriptionCatchupDetails subscriptionCatchupDetails_3_2 = mock(SubscriptionCatchupDetails.class);
 
         when(subscriptionsDescriptorsRegistry.getAll()).thenReturn(asList(
+                subscriptionsDescriptor_3,
                 subscriptionsDescriptor_1,
-                subscriptionsDescriptor_2,
-                subscriptionsDescriptor_3
+                subscriptionsDescriptor_2
         ));
         when(canCatchupFilter.canCatchup(subscriptionsDescriptor_1, catchupCommand)).thenReturn(true);
         when(canCatchupFilter.canCatchup(subscriptionsDescriptor_2, catchupCommand)).thenReturn(false);