Simple Unit test with Mocks keeps failing; mock object not being passed to class?

I have a simple Unit Test that is failing. Hopefully I can explain this in simple terms as I've been looking at it for hours and I see what the issue is, but I am not too familiar the underlying theory behind Mocks so I am a bit confused and cannot fix it. I will summarize the issue very quickly and then paste the code below.

Basically, in my test method called getAllValidModelsTest(), it uses a for loop to iterate thru enum values of object type DeviceModel. There are only 5: [EX3400_24P, EX4300_32F, EX4300_48MP, SRX_345, FAUX].

So inside the for loop, before the Assert statement (Junit), it makes a static method call to getDevice(deviceId) and it should from there return a Device object. The first line under the for loop in the getAllValidModelsTest() mocks the elementMock object to return the current model that is being iterated over in the DeviceModels[] array that was returned from the .values() call on the enums DeviceModel class.

So my issue is, when it jumps in the 2nd iteration in my for loop (counting from 1), the Assert fails , because the 0th element in the DeviceModel[] array is obviously EX4300_32F, but in the @Before setUp annotation it is being mocked to return EX3400_24P. But the weird thing is, under the for loop inside the getAllValidModelsTest() method, it is being overridden/mocked again to return to the current model that is being iterated through when .getModel is called on the elementMock object, so it should be returning the SAME value...

This is how the class SwitchDeviceFactoryTest.java is constructed (the class with the Unit Test):

    @PowerMockIgnore({"javax.net.ssl.*"})
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({DataGatewayFactory.class, SwitchConfig.class, RouterConfig.class})
    public class SwitchDeviceFactoryTest {
       
        String deviceId = "testdevice";
        String ip = "1.1.1.1";
        DataGateway dbMock = Mockito.mock(DataGateway.class);
        SwitchConfig swConfigMock = PowerMockito.mock(SwitchConfig.class);
        RouterConfig routerConfigMock = PowerMockito.mock(RouterConfig.class);
        TransportDeviceSecretsInfo secrets = new TransportDeviceSecretsInfo();
        TransportDeviceSecretsData secretsData = new TransportDeviceSecretsData("root","rootPw", "sshUser", "sshPass", "snmpAuthPass", "snmpPrivPass");
        IElement elementMock = Mockito.mock(IElement.class);
    
        ITransportDeviceSecretsCrud transportDeviceSecretsCrud = mock(ITransportDeviceSecretsCrud.class);
        ISwitchConfigCrud switchConfigCrud = mock(ISwitchConfigCrud.class);
        IRouterConfigCrud routerConfigCrud = mock(IRouterConfigCrud.class);
        IElementCrud elementCrud = mock(IElementCrud.class);

This is my setUp method that runs before the test. The only variables that should be of importance are the elementMock object, specifically the one being mocked to return the EX3400_24P object:

@Before
public void setup() throws Exception {
    secrets.setSecretsData(secretsData);
    PowerMockito.mockStatic(DataGatewayFactory.class);
    Mockito.when(DataGatewayFactory.getInstance()).thenReturn(dbMock);
    Mockito.when(dbMock.getTransportDeviceSecretsCrud()).thenReturn(transportDeviceSecretsCrud);
    Mockito.when(transportDeviceSecretsCrud.getServerSecretsInfo(anyString())).thenReturn(Optional.of(secrets));
    Mockito.when(transportDeviceSecretsCrud.getReportedSecretsInfo(anyString())).thenReturn(Optional.of(secrets));

    when(dbMock.getElementCrud()).thenReturn(elementCrud);
    doReturn(Optional.of(elementMock)).when(elementCrud).getById(anyString());
    Mockito.when(elementMock.getModel()).thenReturn(DeviceModel.EX3400_24P.getModel());

    Mockito.when(elementMock.getType()).thenReturn(ElementType.SWITCH);
    Mockito.when(dbMock.getSwitchConfigCrud()).thenReturn(switchConfigCrud);
    Mockito.when(switchConfigCrud.get(anyString())).thenReturn(Optional.of(swConfigMock));
    Mockito.when(swConfigMock.getIp()).thenReturn(ip);
    Mockito.when(dbMock.getRouterConfigCrud()).thenReturn(routerConfigCrud);
    Mockito.when(routerConfigCrud.get(anyString())).thenReturn(Optional.of(routerConfigMock));
    Mockito.when(routerConfigMock.getIp()).thenReturn(ip);

And the test method:

@Test
public void getAllValidModelsTest() throws Exception {
    for (DeviceModel model: DeviceModel.values()) {
        when(elementMock.getModel()).thenReturn(model.getModel());
        if (model == DeviceModel.SRX_345)
            when(elementMock.getType()).thenReturn(ElementType.ROUTER);
        else
            when(elementMock.getType()).thenReturn(ElementType.SWITCH);
        Device device = DeviceFactory.getDevice(deviceId);
        assertEquals(model, device.getModel());
    }
}

The thing that doesn't make sense, is I was refactoring code, and only changed 2 lines (the elementCrud and elementMock .doReturn and .when calls) and it works perfectly fine on the develop branch.

When I debug, I can see that on the 2nd iteration of the for loop, .getModel returns EX3400_24P object inside the static getDevice method, when it should be returning model.getModel() , which would be the 2nd object being iterated on in the .values() enum array of DeviceModels... so it should be EX4300_32F.

On the develop branch, this works perfectly.... It's as if the Mockito mock object forgets what it's suppose to do when it jumps inside the DeviceFactory class inside the getDevice method once its called in my getAllValidModelsTest() method (i.e. Device device = DeviceFactory.getDevice(deviceId);)

Here is the .getDevice method from the DeviceFactory class:

public static Device getDevice(String serialNumber) throws Exception {
    IElement element = dataGateway.getElementCrud().getById(serialNumber).get();
    DeviceModel model = DeviceModel.valueOfLabel(element.getModel()); // right here is where it returns the wrong model... it returns EX3400_24P on the 2nd iteration
    log.info("Found device {} in database", serialNumber);

    if (serialNumber.startsWith(FakeDevicePrefix.ATGTEST.toString()) || serialNumber.startsWith(FakeDevicePrefix.FAKE.toString())) {
        log.info("Detected FAKE/ATG serial number. Using FAUX device.");
        model = DeviceModel.FAUX;
    }

    switch (element.getType()) {
        case SWITCH:
            SwitchConfig config = dataGateway.getSwitchConfigCrud().get(serialNumber).get();
            return getDevice(serialNumber, config.getIp(), model);
        case ROUTER:
            RouterConfig rconfig = dataGateway.getRouterConfigCrud().get(serialNumber).get();
            return getDevice(serialNumber, rconfig.getIp(), DeviceModel.SRX_345);
        case PTP:
        default:
            log.warn("Unsupported device type {}", element.getType().toString());
            throw new Exception("Unsupported device type " + element.getType().toString());
    }
}

I did indeed comment out/remove the piece of code that mocks it to return EX3400_24P in the setUp() method with @Before annotation , but the tests fails with a NULL POINTER EXCEPTION at this point.

How does the .getModel method know to return what I mocked it to return in the previous class (SwitchDeviceFactoryTest.java) before it jumps into the DeviceFactory.java class? How does it remember that if I'm not passing it in as a variable into the getDevice() method?

Do I need to use PowerMock or something because this is a static method? How does this change anything?

Please help!