Skip to content
This repository was archived by the owner on Aug 13, 2020. It is now read-only.

Commit 3f64d34

Browse files
allanmckenzieallanmckenzie
authored
Merge pull request #761 from CJSCommonPlatform/make-shuttering-registry-singleton
Make shuttering registry a singleton
2 parents 957f95e + 001727d commit 3f64d34

File tree

8 files changed

+149
-72
lines changed

8 files changed

+149
-72
lines changed

‎CHANGELOG.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,11 @@ on [Keep a CHANGELOG](http://keepachangelog.com/). This project adheres to
55

66
## [Unreleased]
77

8+
## [6.0.3] - 2019-08-16
89
### Added
910
- subscriptions_descriptor.yaml location pattern for jms_uri and rest_uri
11+
### Fixed
12+
- ShutteringRegistry is now correctly a singleton
1013

1114
## [6.0.2] - 2019-08-15
1215
### Changed

‎framework-system/framework-management/src/main/java/uk/gov/justice/services/management/shuttering/handler/ShutteringSystemCommandHandler.java‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,16 +3,16 @@
33
import static java.lang.String.format;
44
import static uk.gov.justice.services.jmx.api.command.ShutterSystemCommand.SHUTTER;
55
import static uk.gov.justice.services.jmx.api.command.UnshutterSystemCommand.UNSHUTTER;
6-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_SHUTTERED;
7-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_UNSHUTTERED;
6+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERED;
7+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERED;
88

99
import uk.gov.justice.services.common.util.UtcClock;
1010
import uk.gov.justice.services.jmx.api.command.ShutterSystemCommand;
1111
import uk.gov.justice.services.jmx.api.command.UnshutterSystemCommand;
1212
import uk.gov.justice.services.jmx.command.HandlesSystemCommand;
1313
import uk.gov.justice.services.management.shuttering.events.ShutteringRequestedEvent;
1414
import uk.gov.justice.services.management.shuttering.events.UnshutteringRequestedEvent;
15-
import uk.gov.justice.services.management.shuttering.observers.ContextShutteredStateObserver;
15+
import uk.gov.justice.services.management.shuttering.observers.ShutteringStateRegistry;
1616
import uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState;
1717

1818
import javax.enterprise.event.Event;
@@ -32,15 +32,15 @@ public class ShutteringSystemCommandHandler {
3232
private Event<UnshutteringRequestedEvent> unshutteringRequestedEventFirer;
3333

3434
@Inject
35-
private ContextShutteredStateObserver contextShutteredStateObserver;
35+
private ShutteringStateRegistry shutteringStateRegistry;
3636

3737
@Inject
3838
private Logger logger;
3939

4040
@HandlesSystemCommand(SHUTTER)
4141
public void onShutterRequested(final ShutterSystemCommand shutterSystemCommand) {
42-
final ContextShutteredState shutteredState = contextShutteredStateObserver.getShutteredState();
43-
if(shutteredState == CONTEXT_UNSHUTTERED) {
42+
final ContextShutteredState shutteredState = shutteringStateRegistry.getShutteredState();
43+
if(shutteredState == UNSHUTTERED) {
4444
shutteringRequestedEventFirer.fire(new ShutteringRequestedEvent(shutterSystemCommand, clock.now()));
4545
} else {
4646
logger.info(format("Ignoring command '%s'. Context shuttered state is '%s'", shutterSystemCommand, shutteredState));
@@ -49,8 +49,8 @@ public void onShutterRequested(final ShutterSystemCommand shutterSystemCommand)
4949

5050
@HandlesSystemCommand(UNSHUTTER)
5151
public void onUnshutterRequested(final UnshutterSystemCommand unshutterSystemCommand) {
52-
final ContextShutteredState shutteredState = contextShutteredStateObserver.getShutteredState();
53-
if(shutteredState == CONTEXT_SHUTTERED) {
52+
final ContextShutteredState shutteredState = shutteringStateRegistry.getShutteredState();
53+
if(shutteredState == SHUTTERED) {
5454
unshutteringRequestedEventFirer.fire(new UnshutteringRequestedEvent(unshutterSystemCommand, clock.now()));
5555
} else {
5656
logger.info(format("Ignoring command '%s'. Context shuttered state is '%s'", unshutterSystemCommand, shutteredState));

framework-system/framework-management/src/main/java/uk/gov/justice/services/management/shuttering/observers/ContextShutteredStateObserver.java renamed to framework-system/framework-management/src/main/java/uk/gov/justice/services/management/shuttering/observers/ApplicationShutteredStateObserver.java

Lines changed: 12 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,43 +1,36 @@
11
package uk.gov.justice.services.management.shuttering.observers;
22

3-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_SHUTTERED;
4-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_UNSHUTTERED;
5-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_STARTED;
6-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_STARTED;
3+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERED;
4+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_IN_PROGRESS;
5+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERED;
6+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_IN_PROGRESS;
77

88
import uk.gov.justice.services.management.shuttering.events.ShutteringCompleteEvent;
99
import uk.gov.justice.services.management.shuttering.events.ShutteringRequestedEvent;
1010
import uk.gov.justice.services.management.shuttering.events.UnshutteringCompleteEvent;
1111
import uk.gov.justice.services.management.shuttering.events.UnshutteringRequestedEvent;
12-
import uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState;
13-
14-
import java.util.concurrent.atomic.AtomicReference;
1512

1613
import javax.enterprise.event.Observes;
17-
import javax.faces.bean.ApplicationScoped;
14+
import javax.inject.Inject;
1815

19-
@ApplicationScoped
20-
public class ContextShutteredStateObserver {
16+
public class ApplicationShutteredStateObserver {
2117

22-
private final AtomicReference<ContextShutteredState> shutteredState = new AtomicReference<>(CONTEXT_UNSHUTTERED);
18+
@Inject
19+
private ShutteringStateRegistry shutteringStateRegistry;
2320

2421
public void onShutteringRequested(@SuppressWarnings("unused") @Observes final ShutteringRequestedEvent shutteringRequestedEvent) {
25-
shutteredState.set(SHUTTERING_STARTED);
22+
shutteringStateRegistry.setShutteredState(SHUTTERING_IN_PROGRESS);
2623
}
2724

2825
public void onShutteringComplete(@SuppressWarnings("unused") @Observes final ShutteringCompleteEvent shutteringCompleteEvent) {
29-
shutteredState.set(CONTEXT_SHUTTERED);
26+
shutteringStateRegistry.setShutteredState(SHUTTERED);
3027
}
3128

3229
public void onUnshutteringRequested(@SuppressWarnings("unused") @Observes final UnshutteringRequestedEvent unshutteringRequestedEvent) {
33-
shutteredState.set(UNSHUTTERING_STARTED);
30+
shutteringStateRegistry.setShutteredState(UNSHUTTERING_IN_PROGRESS);
3431
}
3532

3633
public void onUnshutteringComplete(@SuppressWarnings("unused") @Observes final UnshutteringCompleteEvent unshutteringCompleteEvent) {
37-
shutteredState.set(CONTEXT_UNSHUTTERED);
38-
}
39-
40-
public ContextShutteredState getShutteredState() {
41-
return shutteredState.get();
34+
shutteringStateRegistry.setShutteredState(UNSHUTTERED);
4235
}
4336
}

‎framework-system/framework-management/src/main/java/uk/gov/justice/services/management/shuttering/observers/ShutteringStateRegistry.java‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
package uk.gov.justice.services.management.shuttering.observers;
2+
3+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERED;
4+
5+
import uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState;
6+
7+
import java.util.concurrent.atomic.AtomicReference;
8+
9+
import javax.inject.Singleton;
10+
11+
@Singleton
12+
public class ShutteringStateRegistry {
13+
14+
private final AtomicReference<ContextShutteredState> shutteredState = new AtomicReference<>(UNSHUTTERED);
15+
16+
public void setShutteredState(final ContextShutteredState contextShutteredState) {
17+
shutteredState.set(contextShutteredState);
18+
}
19+
20+
public ContextShutteredState getShutteredState() {
21+
return shutteredState.get();
22+
}
23+
}

‎framework-system/framework-management/src/main/java/uk/gov/justice/services/management/shuttering/observers/shuttering/ContextShutteredState.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,8 @@
22

33
public enum ContextShutteredState {
44

5-
SHUTTERING_STARTED,
6-
CONTEXT_SHUTTERED,
7-
UNSHUTTERING_STARTED,
8-
CONTEXT_UNSHUTTERED
5+
SHUTTERING_IN_PROGRESS,
6+
SHUTTERED,
7+
UNSHUTTERING_IN_PROGRESS,
8+
UNSHUTTERED
99
}

‎framework-system/framework-management/src/test/java/uk/gov/justice/services/management/shuttering/handler/ShutteringSystemCommandHandlerTest.java‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -5,17 +5,17 @@
55
import static org.mockito.Mockito.verify;
66
import static org.mockito.Mockito.verifyZeroInteractions;
77
import static org.mockito.Mockito.when;
8-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_SHUTTERED;
9-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_UNSHUTTERED;
10-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_STARTED;
11-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_STARTED;
8+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERED;
9+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERED;
10+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_IN_PROGRESS;
11+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_IN_PROGRESS;
1212

1313
import uk.gov.justice.services.common.util.UtcClock;
1414
import uk.gov.justice.services.jmx.api.command.ShutterSystemCommand;
1515
import uk.gov.justice.services.jmx.api.command.UnshutterSystemCommand;
1616
import uk.gov.justice.services.management.shuttering.events.ShutteringRequestedEvent;
1717
import uk.gov.justice.services.management.shuttering.events.UnshutteringRequestedEvent;
18-
import uk.gov.justice.services.management.shuttering.observers.ContextShutteredStateObserver;
18+
import uk.gov.justice.services.management.shuttering.observers.ShutteringStateRegistry;
1919

2020
import java.time.ZonedDateTime;
2121

@@ -43,7 +43,7 @@ public class ShutteringSystemCommandHandlerTest {
4343
private Event<UnshutteringRequestedEvent> unshutteringRequestedEventFirer;
4444

4545
@Mock
46-
private ContextShutteredStateObserver contextShutteredStateObserver;
46+
private ShutteringStateRegistry shutteringStateRegistry;
4747

4848
@Mock
4949
private Logger logger;
@@ -63,7 +63,7 @@ public void shouldFireEventOnShutteringRequested() throws Exception {
6363
final ZonedDateTime now = new UtcClock().now();
6464
final ShutterSystemCommand shutterSystemCommand = new ShutterSystemCommand();
6565

66-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(CONTEXT_UNSHUTTERED);
66+
when(shutteringStateRegistry.getShutteredState()).thenReturn(UNSHUTTERED);
6767
when(clock.now()).thenReturn(now);
6868

6969
shutteringSystemCommandHandler.onShutterRequested(shutterSystemCommand);
@@ -82,7 +82,7 @@ public void shouldFireEventOnUnshutteringRequested() throws Exception {
8282
final ZonedDateTime now = new UtcClock().now();
8383
final UnshutterSystemCommand unshutterSystemCommand = new UnshutterSystemCommand();
8484

85-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(CONTEXT_SHUTTERED);
85+
when(shutteringStateRegistry.getShutteredState()).thenReturn(SHUTTERED);
8686
when(clock.now()).thenReturn(now);
8787

8888
shutteringSystemCommandHandler.onUnshutterRequested(unshutterSystemCommand);
@@ -98,66 +98,66 @@ public void shouldFireEventOnUnshutteringRequested() throws Exception {
9898
@Test
9999
public void shouldIgnoreShutteringRequestIfTheShutteredStateIsContextShuttered() throws Exception {
100100

101-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(CONTEXT_SHUTTERED);
101+
when(shutteringStateRegistry.getShutteredState()).thenReturn(SHUTTERED);
102102

103103
shutteringSystemCommandHandler.onShutterRequested(new ShutterSystemCommand());
104104

105105
verifyZeroInteractions(shutteringRequestedEventFirer);
106-
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'CONTEXT_SHUTTERED'");
106+
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'SHUTTERED'");
107107
}
108108

109109
@Test
110110
public void shouldIgnoreShutteringRequestIfTheShutteredStateIsShutteringStarted() throws Exception {
111111

112-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(SHUTTERING_STARTED);
112+
when(shutteringStateRegistry.getShutteredState()).thenReturn(SHUTTERING_IN_PROGRESS);
113113

114114
shutteringSystemCommandHandler.onShutterRequested(new ShutterSystemCommand());
115115

116116
verifyZeroInteractions(shutteringRequestedEventFirer);
117-
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'SHUTTERING_STARTED'");
117+
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'SHUTTERING_IN_PROGRESS'");
118118
}
119119

120120
@Test
121121
public void shouldIgnoreShutteringRequestIfTheShutteredStateIsUnshutteringStarted() throws Exception {
122122

123-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(UNSHUTTERING_STARTED);
123+
when(shutteringStateRegistry.getShutteredState()).thenReturn(UNSHUTTERING_IN_PROGRESS);
124124

125125
shutteringSystemCommandHandler.onShutterRequested(new ShutterSystemCommand());
126126

127127
verifyZeroInteractions(shutteringRequestedEventFirer);
128-
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'UNSHUTTERING_STARTED'");
128+
verify(logger).info("Ignoring command 'SHUTTER'. Context shuttered state is 'UNSHUTTERING_IN_PROGRESS'");
129129
}
130130

131131
@Test
132132
public void shouldIgnoreUnshutteringRequestIfTheShutteredStateIsContextUnshuttered() throws Exception {
133133

134-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(CONTEXT_UNSHUTTERED);
134+
when(shutteringStateRegistry.getShutteredState()).thenReturn(UNSHUTTERED);
135135

136136
shutteringSystemCommandHandler.onUnshutterRequested(new UnshutterSystemCommand());
137137

138138
verifyZeroInteractions(shutteringRequestedEventFirer);
139-
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'CONTEXT_UNSHUTTERED'");
139+
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'UNSHUTTERED'");
140140
}
141141

142142
@Test
143143
public void shouldIgnoreUnshutteringRequestIfTheShutteredStateIsShutteringStarted() throws Exception {
144144

145-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(SHUTTERING_STARTED);
145+
when(shutteringStateRegistry.getShutteredState()).thenReturn(SHUTTERING_IN_PROGRESS);
146146

147147
shutteringSystemCommandHandler.onUnshutterRequested(new UnshutterSystemCommand());
148148

149149
verifyZeroInteractions(shutteringRequestedEventFirer);
150-
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'SHUTTERING_STARTED'");
150+
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'SHUTTERING_IN_PROGRESS'");
151151
}
152152

153153
@Test
154154
public void shouldIgnoreUnshutteringRequestIfTheShutteredStateIsUnshutteringStarted() throws Exception {
155155

156-
when(contextShutteredStateObserver.getShutteredState()).thenReturn(UNSHUTTERING_STARTED);
156+
when(shutteringStateRegistry.getShutteredState()).thenReturn(UNSHUTTERING_IN_PROGRESS);
157157

158158
shutteringSystemCommandHandler.onUnshutterRequested(new UnshutterSystemCommand());
159159

160160
verifyZeroInteractions(shutteringRequestedEventFirer);
161-
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'UNSHUTTERING_STARTED'");
161+
verify(logger).info("Ignoring command 'UNSHUTTER'. Context shuttered state is 'UNSHUTTERING_IN_PROGRESS'");
162162
}
163163
}

framework-system/framework-management/src/test/java/uk/gov/justice/services/management/shuttering/observers/ContextShutteredStateObserverTest.java renamed to framework-system/framework-management/src/test/java/uk/gov/justice/services/management/shuttering/observers/ApplicationShutteredStateObserverTest.java

Lines changed: 41 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,49 +1,69 @@
11
package uk.gov.justice.services.management.shuttering.observers;
22

3-
import static org.hamcrest.CoreMatchers.is;
4-
import static org.junit.Assert.assertThat;
53
import static org.mockito.Mockito.mock;
6-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_SHUTTERED;
7-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.CONTEXT_UNSHUTTERED;
8-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_STARTED;
9-
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_STARTED;
4+
import static org.mockito.Mockito.verify;
5+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERED;
6+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.SHUTTERING_IN_PROGRESS;
7+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERED;
8+
import static uk.gov.justice.services.management.shuttering.observers.shuttering.ContextShutteredState.UNSHUTTERING_IN_PROGRESS;
109

1110
import uk.gov.justice.services.management.shuttering.events.ShutteringCompleteEvent;
1211
import uk.gov.justice.services.management.shuttering.events.ShutteringRequestedEvent;
1312
import uk.gov.justice.services.management.shuttering.events.UnshutteringCompleteEvent;
1413
import uk.gov.justice.services.management.shuttering.events.UnshutteringRequestedEvent;
1514

1615
import org.junit.Test;
16+
import org.junit.runner.RunWith;
17+
import org.mockito.InjectMocks;
18+
import org.mockito.Mock;
19+
import org.mockito.runners.MockitoJUnitRunner;
1720

18-
public class ContextShutteredStateObserverTest {
21+
@RunWith(MockitoJUnitRunner.class)
22+
public class ApplicationShutteredStateObserverTest {
23+
24+
@Mock
25+
private ShutteringStateRegistry shutteringStateRegistry;
26+
27+
@InjectMocks
28+
private ApplicationShutteredStateObserver contextShutteredStateObserver;
1929

2030
@Test
21-
public void shouldBeUnshutteredWhenClassInstantiated() throws Exception {
31+
public void shouldSetShutteringInProgressOnShutteringRequested() throws Exception {
32+
33+
final ShutteringRequestedEvent shutteringRequestedEvent = mock(ShutteringRequestedEvent.class);
34+
35+
contextShutteredStateObserver.onShutteringRequested(shutteringRequestedEvent);
2236

23-
assertThat(new ContextShutteredStateObserver().getShutteredState(), is(CONTEXT_UNSHUTTERED));
37+
verify(shutteringStateRegistry).setShutteredState(SHUTTERING_IN_PROGRESS);
2438
}
2539

2640
@Test
27-
public void shouldCorrectlySetState() throws Exception {
41+
public void shouldSetShutteringInProgressOnShutteringCompete() throws Exception {
2842

29-
final ContextShutteredStateObserver contextShutteredStateObserver = new ContextShutteredStateObserver();
30-
final ShutteringRequestedEvent shutteringRequestedEvent = mock(ShutteringRequestedEvent.class);
3143
final ShutteringCompleteEvent shutteringCompleteEvent = mock(ShutteringCompleteEvent.class);
32-
final UnshutteringRequestedEvent unshutteringRequestedEvent = mock(UnshutteringRequestedEvent.class);
33-
final UnshutteringCompleteEvent unshutteringCompleteEvent = mock(UnshutteringCompleteEvent.class);
3444

35-
assertThat(contextShutteredStateObserver.getShutteredState(), is(CONTEXT_UNSHUTTERED));
45+
contextShutteredStateObserver.onShutteringComplete(shutteringCompleteEvent);
3646

37-
contextShutteredStateObserver.onShutteringRequested(shutteringRequestedEvent);
38-
assertThat(contextShutteredStateObserver.getShutteredState(), is(SHUTTERING_STARTED));
47+
verify(shutteringStateRegistry).setShutteredState(SHUTTERED);
48+
}
3949

40-
contextShutteredStateObserver.onShutteringComplete(shutteringCompleteEvent);
41-
assertThat(contextShutteredStateObserver.getShutteredState(), is(CONTEXT_SHUTTERED));
50+
@Test
51+
public void shouldSetShutteringInProgressOnUnshutteringRequested() throws Exception {
52+
53+
final UnshutteringRequestedEvent unshutteringRequestedEvent = mock(UnshutteringRequestedEvent.class);
4254

4355
contextShutteredStateObserver.onUnshutteringRequested(unshutteringRequestedEvent);
44-
assertThat(contextShutteredStateObserver.getShutteredState(), is(UNSHUTTERING_STARTED));
56+
57+
verify(shutteringStateRegistry).setShutteredState(UNSHUTTERING_IN_PROGRESS);
58+
}
59+
60+
@Test
61+
public void shouldSetShutteringInProgressOnUnshutteringComplete() throws Exception {
62+
63+
final UnshutteringCompleteEvent unshutteringCompleteEvent = mock(UnshutteringCompleteEvent.class);
4564

4665
contextShutteredStateObserver.onUnshutteringComplete(unshutteringCompleteEvent);
47-
assertThat(contextShutteredStateObserver.getShutteredState(), is(CONTEXT_UNSHUTTERED));
66+
67+
verify(shutteringStateRegistry).setShutteredState(UNSHUTTERED);
4868
}
4969
}

0 commit comments

Comments
 (0)