org.springframework.statemachine.StateMachineContext Java Examples

@Test
public void testRestoreFromInstallUsingInstallRequest() throws Exception {
	Mockito.when(releaseService.install(any(InstallRequest.class))).thenReturn(new Release());

	DefaultExtendedState extendedState = new DefaultExtendedState();
	extendedState.getVariables().put(SkipperEventHeaders.INSTALL_REQUEST, new InstallRequest());

	StateMachineContext<SkipperStates, SkipperEvents> stateMachineContext = new DefaultStateMachineContext<>(
			SkipperStates.INSTALL, SkipperEvents.INSTALL, null, extendedState);
	Mockito.when(stateMachineRuntimePersister.read(any())).thenReturn(stateMachineContext);

	StateMachineService<SkipperStates, SkipperEvents> stateMachineService = context.getBean(StateMachineService.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = stateMachineService
			.acquireStateMachine("testRestoreFromInstallUsingInstallRequest", false);

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(2)
					.and()
				.build();
	plan.test();

	Mockito.verify(upgradeCancelAction, never()).execute(any());
	Mockito.verify(errorAction, never()).execute(any());
}
 

@Test
public void testRestoreFromUpgradeUsingUpgradeRequest() throws Exception {
	Manifest manifest = new Manifest();
	Release release = new Release();
	release.setManifest(manifest);
	Mockito.when(releaseReportService.createReport(any(), any(), any(boolean.class))).thenReturn(new ReleaseAnalysisReport(
			new ArrayList<>(), new ReleaseDifference(), release, release));
	Mockito.when(upgradeStrategy.checkStatus(any()))
			.thenReturn(true);
	Mockito.when(upgradeStrategyFactory.getUpgradeStrategy(any())).thenReturn(upgradeStrategy);

	DefaultExtendedState extendedState = new DefaultExtendedState();
	extendedState.getVariables().put(SkipperEventHeaders.UPGRADE_REQUEST, new UpgradeRequest());

	StateMachineContext<SkipperStates, SkipperEvents> stateMachineContext = new DefaultStateMachineContext<>(
			SkipperStates.UPGRADE, SkipperEvents.UPGRADE, null, extendedState);
	Mockito.when(stateMachineRuntimePersister.read(any())).thenReturn(stateMachineContext);

	StateMachineService<SkipperStates, SkipperEvents> stateMachineService = context.getBean(StateMachineService.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = stateMachineService
			.acquireStateMachine("testRestoreFromUpgradeUsingUpgradeRequest", false);

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(8)
					.and()
				.build();
	plan.test();
	Mockito.verify(upgradeCancelAction, never()).execute(any());
	Mockito.verify(errorAction, never()).execute(any());
}
 

@Test
public void testRestoreFromInstallUsingInstallProperties() throws Exception {
	Mockito.when(releaseService.install(any(), any(InstallProperties.class))).thenReturn(new Release());

	DefaultExtendedState extendedState = new DefaultExtendedState();
	extendedState.getVariables().put(SkipperEventHeaders.INSTALL_PROPERTIES, new InstallProperties());

	StateMachineContext<SkipperStates, SkipperEvents> stateMachineContext = new DefaultStateMachineContext<>(
			SkipperStates.INSTALL, SkipperEvents.INSTALL, null, extendedState);
	Mockito.when(stateMachineRuntimePersister.read(any())).thenReturn(stateMachineContext);

	StateMachineService<SkipperStates, SkipperEvents> stateMachineService = context.getBean(StateMachineService.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = stateMachineService
			.acquireStateMachine("testRestoreFromInstallUsingInstallProperties", false);

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(2)
					.and()
				.build();
	plan.test();

	Mockito.verify(upgradeCancelAction, never()).execute(any());
	Mockito.verify(errorAction, never()).execute(any());
}
 

@Test
public void testRestoreFromDeleteUsingDeleteProperties() throws Exception {
	Mockito.when(releaseService.delete(nullable(String.class), any(boolean.class))).thenReturn(new Release());
	DeleteProperties deleteProperties = new DeleteProperties();

	DefaultExtendedState extendedState = new DefaultExtendedState();
	extendedState.getVariables().put(SkipperEventHeaders.RELEASE_DELETE_PROPERTIES, deleteProperties);

	StateMachineContext<SkipperStates, SkipperEvents> stateMachineContext = new DefaultStateMachineContext<>(
			SkipperStates.DELETE, SkipperEvents.DELETE, null, extendedState);
	Mockito.when(stateMachineRuntimePersister.read(any())).thenReturn(stateMachineContext);

	StateMachineService<SkipperStates, SkipperEvents> stateMachineService = context.getBean(StateMachineService.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = stateMachineService
			.acquireStateMachine("testRestoreFromDeleteUsingDeleteProperties", false);

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(2)
					.and()
				.build();
	plan.test();

	Mockito.verify(upgradeCancelAction, never()).execute(any());
	Mockito.verify(errorAction, never()).execute(any());
}
 

@Override
public StateMachineContext getStateMachineContext() {
    return context;
}
 

@Override
public void setStateMachineContext(StateMachineContext context) {
    this.context = context;
}
 

@Override
public void write(StateMachineContext<S, E> context, StateMachineContextEntity<S, E> contextObj) throws Exception {
    contextObj.setStateMachineContext(context);
}
 

@Override
public StateMachineContext<S, E> read(StateMachineContextEntity<S, E> contextObj) throws Exception {
    return contextObj.getStateMachineContext();
}
 

@Override
public void write(StateMachineContext<TurnstileStates, TurnstileEvents> stateMachineContext, Integer integer) throws Exception {
    cache.put(integer, stateMachineContext.getState());
}
 

@Override
public StateMachineContext<TurnstileStates, TurnstileEvents> read(Integer integer) throws Exception {
    return cache.containsKey(integer) ?
            new DefaultStateMachineContext<>(cache.get(integer), null, null, null, null, "turnstileStateMachine") :
            new DefaultStateMachineContext<>(TurnstileStates.Locked, null, null, null, null, "turnstileStateMachine");
}
 

StateMachineContext<S, E> getStateMachineContext(); 

void setStateMachineContext(StateMachineContext<S, E> context);