TestingConfiguration.java

package unit.ui;

import devices.PowerSupply;
import kernel.Kernel;
import kernel.controllers.PVCiPressureGaugeFactory;
import kernel.views.DeviceContainer;
import kernel.controllers.TDKLambdaPowerSupplyFactory;
import kernel.views.CommPortReporter;
import kernel.views.VariableProviderContainer;
import kernel.views.variables.*;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.integration.junit4.JUnit4Mockery;
import org.jmock.lib.concurrent.Synchroniser;
import org.springframework.context.annotation.*;
import ui.UserInterfaceConfiguration;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

@Configuration
@Import(UserInterfaceConfiguration.class)
@Lazy
public class TestingConfiguration {

    private volatile Kernel mockKernel;

    private volatile Mockery mockingContext;

    private volatile List<String> portList;

    private volatile DeviceContainer mockDeviceContainerView;

    private volatile VariableProviderContainer mockVariableProviderContainer;

    private volatile MockVoltageProvider mockVoltageProvider =
            new MockVoltageProvider();

    @Bean
    @Scope("singleton")
    public Mockery mockingContext(){
        if(mockingContext == null) {
            mockingContext = new SynchronizedJUnit4Mockery();
        }
        return mockingContext;
    }

    @Bean
    @Scope("singleton")
    public List<String> testData(){
        portList = new ArrayList<>();
        portList.add("/dev/ttyUSB0");
        return portList;
    }

    @Bean
    @Scope("singleton")
    public CommPortReporter portReporter(){
        return mockingContext().mock(CommPortReporter.class);
    }

    @Bean
    @Scope("singleton")
    public TDKLambdaPowerSupplyFactory tdkLambdaPowerSupplyFactory(){
        return mockingContext().mock(TDKLambdaPowerSupplyFactory.class);
    }

    @Bean
    @Scope("singleton")
    public PVCiPressureGaugeFactory pvCiPressureGaugeFactory(){
        return mockingContext().mock(PVCiPressureGaugeFactory.class);
    }

    @Bean
    @Scope("singleton")
    public DeviceContainer deviceRegistryView(){
        if(mockDeviceContainerView == null){
            mockDeviceContainerView = mockingContext().mock(
                    DeviceContainer.class
            );
        }
        return mockDeviceContainerView;
    }

    @Bean
    @Scope("singleton")
    public VariableProviderContainer variableProviderRegistry(){
        if (mockVariableProviderContainer == null){
            mockVariableProviderContainer = mockingContext().mock(
                    VariableProviderContainer.class
            );
        }
        return mockVariableProviderContainer;
    }

    @Bean
    @Scope("singleton")
    public PowerSupply powerSupply(){
        return mockingContext().mock(PowerSupply.class);
    }

    @Bean
    @Scope("singleton")
    public PressureProvider pressureProvider(){
        return mockingContext().mock(PressureProvider.class);
    }

    @Bean
    @Scope("singleton")
    public VoltageProvider voltageProvider(){
        return mockVoltageProvider;
    }

    @Bean
    @Scope("singleton")
    public Kernel kernel() throws Exception {
        mockKernel = mockingContext().mock(Kernel.class);
        mockingContext().checking(new ExpectationsForKernel());
        return mockKernel;
    }

    private class SynchronizedJUnit4Mockery extends JUnit4Mockery {
        public SynchronizedJUnit4Mockery(){
            setThreadingPolicy(new Synchroniser());
        }
    }

    private class ExpectationsForKernel extends Expectations {
        public ExpectationsForKernel() throws Exception {
            expectationsForPortReporter();
            expectationsForSerialPortNames();
            expectationsForFactory();
            expectationsForPressureGaugeFactory();
            expectationsForDeviceRegistryView();
            expectationsForVariableProvider();
            expectationsForGetPressureProvider();
            expectationsForGetVoltageProvider();
        }

        private void expectationsForPortReporter(){
            allowing(mockKernel).getCommPortReporter();
            will(returnValue(portReporter()));
        }

        private void expectationsForSerialPortNames() {
            allowing(portReporter()).getSerialPortNames();
            will(returnValue(testData()));
        }

        private void expectationsForFactory(){
            allowing(mockKernel).getPowerSupplyFactory();
            will(returnValue(tdkLambdaPowerSupplyFactory()));
        }

        private void expectationsForDeviceRegistryView(){
            allowing(mockKernel).getDeviceRegistryView();
            will(returnValue(deviceRegistryView()));
        }

        private void expectationsForPressureGaugeFactory(){
            allowing(mockKernel).getPressureGaugeFactory();
            will(returnValue(pvCiPressureGaugeFactory()));
        }

        private void expectationsForVariableProvider(){
            allowing(mockKernel).getVariableProvidersView();
            will(returnValue(variableProviderRegistry()));
        }

        private void expectationsForGetPressureProvider() throws Exception {
            allowing(variableProviderRegistry()).getPressureProvider();
            will(returnValue(pressureProvider()));

            allowing(variableProviderRegistry()).hasPressureProvider();
            will(returnValue(Boolean.TRUE));

            allowing(pressureProvider()).setPollingInterval(
                    with(any(Duration.class))
            );
            allowing(pressureProvider()).addOnChangeListener(
                    with(any(VariableChangeEventListener.class))
            );
        }

        private void expectationsForGetVoltageProvider() throws Exception {
            allowing(variableProviderRegistry()).getVoltageProvider();
            will(returnValue(voltageProvider()));
            allowing(variableProviderRegistry()).hasVoltageProvider();
            will(returnValue(Boolean.TRUE));
        }
    }
}