UmlStateMachineModelFactory - inconsistency between StateMachineModel and StateMachine - duplicated transitions created!

[pdalfarr]

Using simple-root-regions.uml to perform some tests, I encountered an unexpected situation where the 'transitions per regions' are not consistent between StateMachineModel and StateMachine.

I am using the simple-root-regions.uml file from this repository to create a StateMachineModel.

This StateMachineModel contains:

• Region1 with 1 'non-initial' transition "S1->S2"
• Region2 with 1 'non-initial' transition "S3->S4"

When I create a StateMachine based on this StateMachineModel, I end up with a StateMachine containing:

• Region1 with 1 'non-initial' transition "S1->S2"
• Region2 with 1 'non-initial' transition "S3->S4" AND the "S1->S2" again! "S1->S2" transition is duplicated in Region 2.

So it seems the "S1->S2" from Region1 has been duplicated in Regon2 as illustrated below.

Unit test available :-)

I created a unit test avalable here to help you troubleshot the issue. This unit test does compare a StateMachineModel and a StateMachine regarding:

• the states per region (this part is OK)
• the transitions per region (this part is NOT OK becasue of the duplicated transition "S1->S2")

[pdalfarr]

Adding the unit test in this ticket.

So the last assertion does fail:

assertThat(transitionsOfRegion2InStateMachine).isEqualTo(transitionsOfRegion2InStateMachineModel);

Unit test to add in UmlStateMachineModelFactoryTests.java :

    public void testStateMachineVsStateMachineModelConsistency() {
        context.refresh();
        Resource model1 = new ClassPathResource("org/springframework/statemachine/uml/simple-root-regions.uml");
        UmlStateMachineModelFactory builder = new UmlStateMachineModelFactory(model1);
        builder.setBeanFactory(context);
        assertThat(model1.exists()).isTrue();
        StateMachineModel<String, String> stateMachineModel = builder.build();

        try {
            // build statemachine from model
            UmlStateMachineModelFactory umlStateMachineModelFactory = new UmlStateMachineModelFactory(("classpath:org/springframework/statemachine/uml/simple-root-regions.uml"));
            StateMachineBuilder.Builder<String, String> stateMachineBuilder = StateMachineBuilder.builder();
            stateMachineBuilder.configureModel().withModel().factory(umlStateMachineModelFactory);
            stateMachineBuilder.configureConfiguration().withConfiguration();
            StateMachine<String, String> stateMachine = stateMachineBuilder.build();

            // get the "root" state of this state machines
            State<String, String> rootState = stateMachine.getStates().stream().findFirst().get();
            assertThat(rootState).isInstanceOf(RegionState.class);
            RegionState<String, String> rootRegionState = ((RegionState<String, String>) rootState);

            // compare statemachine and stateMachineModel

            // states in Region1
            AbstractStateMachine region1InStatemachine = (AbstractStateMachine)
                    ((List) rootRegionState.getRegions()).stream()
                            .filter(region -> ((AbstractStateMachine) region).getId().contains("Region1"))
                            .findFirst().get();

            List statesOfRegion1InStateMachine = region1InStatemachine.getStates().stream()
                    .map(o -> ((State) o).getId().toString())
                    .sorted().toList();

            List<String> statesOfRegion1InStateMachineModel = stateMachineModel.getStatesData().getStateData().stream()
                    .filter(stateData -> "Region1".equals(stateData.getRegion().toString()))
                    .map(stateData -> stateData.getState().toString())
                    .sorted().toList();

            assertThat(statesOfRegion1InStateMachine).isEqualTo(statesOfRegion1InStateMachineModel);

            // states in Region2
            AbstractStateMachine region2InStatemachine = (AbstractStateMachine)
                    ((List) rootRegionState.getRegions()).stream()
                            .filter(region -> ((AbstractStateMachine) region).getId().contains("Region2"))
                            .findFirst().get();

            List statesOfRegion2InStateMachine = region2InStatemachine.getStates().stream()
                    .map(o -> ((State) o).getId().toString())
                    .sorted().toList();

            List<String> statesOfRegion2InStateMachineModel = stateMachineModel.getStatesData().getStateData().stream()
                    .filter(stateData -> "Region2".equals(stateData.getRegion().toString()))
                    .map(stateData -> stateData.getState().toString())
                    .sorted().toList();

            assertThat(statesOfRegion2InStateMachine).isEqualTo(statesOfRegion2InStateMachineModel);

            // transitions in Region1
            List transitionsOfRegion1InStateMachine = region1InStatemachine.getTransitions().stream()
                    .map(o -> ((Transition) o).getSource().getId().toString() + "->" + ((Transition) o).getTarget().getId().toString())
                    .sorted().toList();

            List<String> transitionsOfRegion1InStateMachineModel = stateMachineModel.getTransitionsData().getTransitions().stream()
                    // let's exclude "initial" transition
                    .filter(transitionData -> !transitionData.getSource().startsWith("initial"))
                    .filter(transitionData -> statesOfRegion1InStateMachine.contains(transitionData.getSource())
                            || statesOfRegion1InStateMachine.contains(transitionData.getTarget()))
                    .map(transitionData -> transitionData.getSource() + "->" + transitionData.getTarget())
                    .sorted().toList();

            assertThat(transitionsOfRegion1InStateMachine).isEqualTo(transitionsOfRegion1InStateMachineModel);

            // transitions in Region2
            List transitionsOfRegion2InStateMachine = region2InStatemachine.getTransitions().stream()
                    .map(o -> ((Transition) o).getSource().getId().toString() + "->" + ((Transition) o).getTarget().getId().toString())
                    .sorted().toList();

            List<String> transitionsOfRegion2InStateMachineModel = stateMachineModel.getTransitionsData().getTransitions().stream()
                    // let's exclude "initial" transition
                    .filter(transitionData -> !transitionData.getSource().startsWith("initial"))
                    .filter(transitionData -> statesOfRegion2InStateMachine.contains(transitionData.getSource())
                            || statesOfRegion2InStateMachine.contains(transitionData.getTarget()))
                    .map(transitionData -> transitionData.getSource() + "->" + transitionData.getTarget())
                    .sorted().toList();

            // WOW! this is failing! Why is transition "S1->S2" present in both Region1 AND Region2 ?!?
            // Does this indicates an issue in UmlStateMachineModelFactory ???
            // Expected :["S1->S2"]
            // Actual   :["S1->S2", "S3->S4"]
            assertThat(transitionsOfRegion2InStateMachine).isEqualTo(transitionsOfRegion2InStateMachineModel);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }