mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-03-27 14:23:56 +00:00
[AB-78] adding new concept of feature modes, with splitting it up to new commands and default mode concept
refactoring command received handler to only load the entities in the same thread as the actual executed commands, so that user initiated context contains valid references from the same thread updating documentation fixing issue when the result of role calculation result in no experience role id
This commit is contained in:
Sheldan
@@ -0,0 +1,82 @@
|
||||
package dev.sheldan.abstracto.core.commands.config.features;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.exception.IncorrectParameterTypeException;
|
||||
import dev.sheldan.abstracto.core.command.exception.InsufficientParametersException;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.config.FeatureMode;
|
||||
import dev.sheldan.abstracto.core.exception.FeatureModeNotFoundException;
|
||||
import dev.sheldan.abstracto.core.exception.FeatureNotFoundException;
|
||||
import dev.sheldan.abstracto.core.service.FeatureConfigService;
|
||||
import dev.sheldan.abstracto.core.service.FeatureModeService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class DisableModeTest {
|
||||
|
||||
@InjectMocks
|
||||
private DisableMode testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Mock
|
||||
private FeatureModeService featureModeService;
|
||||
|
||||
@Test(expected = InsufficientParametersException.class)
|
||||
public void testTooLittleParameters() {
|
||||
CommandTestUtilities.executeNoParametersTest(testUnit);
|
||||
}
|
||||
|
||||
@Test(expected = IncorrectParameterTypeException.class)
|
||||
public void testIncorrectParameterType() {
|
||||
CommandTestUtilities.executeWrongParametersTest(testUnit);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExecuteDisable() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
FeatureEnum featureEnum = Mockito.mock(FeatureEnum.class);
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenReturn(featureEnum);
|
||||
FeatureMode featureMode = Mockito.mock(FeatureMode.class);
|
||||
when(featureModeService.getFeatureModeForKey(modeName)).thenReturn(featureMode);
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
CommandResult commandResultCompletableFuture = testUnit.execute(context);
|
||||
CommandTestUtilities.checkSuccessfulCompletion(commandResultCompletableFuture);
|
||||
verify(featureModeService, times(1)).disableFeatureModeForFeature(featureEnum, context.getUserInitiatedContext().getServer(), featureMode);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureNotFoundException.class)
|
||||
public void testExecuteDisableNotExistingFeature() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenThrow(new FeatureNotFoundException(featureName, new ArrayList<>()));
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
testUnit.execute(context);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureModeNotFoundException.class)
|
||||
public void testExecuteDisableNotExistingFeatureMode() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
FeatureEnum featureEnum = Mockito.mock(FeatureEnum.class);
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenReturn(featureEnum);
|
||||
when(featureModeService.getFeatureModeForKey(modeName)).thenThrow(new FeatureModeNotFoundException(modeName, new ArrayList<>()));
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
testUnit.execute(context);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
package dev.sheldan.abstracto.core.commands.config.features;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.exception.IncorrectParameterTypeException;
|
||||
import dev.sheldan.abstracto.core.command.exception.InsufficientParametersException;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.config.FeatureMode;
|
||||
import dev.sheldan.abstracto.core.exception.FeatureModeNotFoundException;
|
||||
import dev.sheldan.abstracto.core.exception.FeatureNotFoundException;
|
||||
import dev.sheldan.abstracto.core.service.FeatureConfigService;
|
||||
import dev.sheldan.abstracto.core.service.FeatureModeService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class EnableModeTest {
|
||||
|
||||
@InjectMocks
|
||||
private EnableMode testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Mock
|
||||
private FeatureModeService featureModeService;
|
||||
|
||||
@Test(expected = InsufficientParametersException.class)
|
||||
public void testTooLittleParameters() {
|
||||
CommandTestUtilities.executeNoParametersTest(testUnit);
|
||||
}
|
||||
|
||||
@Test(expected = IncorrectParameterTypeException.class)
|
||||
public void testIncorrectParameterType() {
|
||||
CommandTestUtilities.executeWrongParametersTest(testUnit);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExecuteDisable() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
FeatureEnum featureEnum = Mockito.mock(FeatureEnum.class);
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenReturn(featureEnum);
|
||||
FeatureMode featureMode = Mockito.mock(FeatureMode.class);
|
||||
when(featureModeService.getFeatureModeForKey(modeName)).thenReturn(featureMode);
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
CommandResult commandResultCompletableFuture = testUnit.execute(context);
|
||||
CommandTestUtilities.checkSuccessfulCompletion(commandResultCompletableFuture);
|
||||
verify(featureModeService, times(1)).enableFeatureModeForFeature(featureEnum, context.getUserInitiatedContext().getServer(), featureMode);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureNotFoundException.class)
|
||||
public void testExecuteDisableNotExistingFeature() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenThrow(new FeatureNotFoundException(featureName, new ArrayList<>()));
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
testUnit.execute(context);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureModeNotFoundException.class)
|
||||
public void testExecuteDisableNotExistingFeatureMode() {
|
||||
String featureName = "text";
|
||||
String modeName = "mode";
|
||||
FeatureEnum featureEnum = Mockito.mock(FeatureEnum.class);
|
||||
when(featureConfigService.getFeatureEnum(featureName)).thenReturn(featureEnum);
|
||||
when(featureModeService.getFeatureModeForKey(modeName)).thenThrow(new FeatureModeNotFoundException(modeName, new ArrayList<>()));
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(featureName, modeName));
|
||||
testUnit.execute(context);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
package dev.sheldan.abstracto.core.commands.config.features;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.exception.IncorrectParameterTypeException;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.command.service.management.FeatureManagementService;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.exception.FeatureNotFoundException;
|
||||
import dev.sheldan.abstracto.core.models.database.AFeature;
|
||||
import dev.sheldan.abstracto.core.models.template.commands.FeatureModeDisplay;
|
||||
import dev.sheldan.abstracto.core.models.template.commands.FeatureModesModel;
|
||||
import dev.sheldan.abstracto.core.service.ChannelService;
|
||||
import dev.sheldan.abstracto.core.service.FeatureConfigService;
|
||||
import dev.sheldan.abstracto.core.service.FeatureModeService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.*;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class FeatureModesTest {
|
||||
|
||||
@InjectMocks
|
||||
private FeatureModes testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureModeService featureModeService;
|
||||
|
||||
@Mock
|
||||
private ChannelService channelService;
|
||||
|
||||
@Mock
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Mock
|
||||
private FeatureManagementService featureManagementService;
|
||||
|
||||
@Captor
|
||||
private ArgumentCaptor<FeatureModesModel> modelCaptor;
|
||||
|
||||
private static final String FEATURE_NAME = "feature";
|
||||
|
||||
@Test(expected = IncorrectParameterTypeException.class)
|
||||
public void testIncorrectParameterType() {
|
||||
CommandTestUtilities.executeWrongParametersTestAsync(testUnit);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExecuteNoParameters() {
|
||||
CommandContext noParameters = CommandTestUtilities.getNoParameters();
|
||||
FeatureModeDisplay display1 = Mockito.mock(FeatureModeDisplay.class);
|
||||
FeatureModeDisplay display2 = Mockito.mock(FeatureModeDisplay.class);
|
||||
List<FeatureModeDisplay> featureModeDisplays = Arrays.asList(display1, display2);
|
||||
when(featureModeService.getEffectiveFeatureModes(noParameters.getUserInitiatedContext().getServer())).thenReturn(featureModeDisplays);
|
||||
when(channelService.sendEmbedTemplateInChannel(eq(FeatureModes.FEATURE_MODES_RESPONSE_TEMPLATE_KEY), modelCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(new ArrayList<>());
|
||||
CompletableFuture<CommandResult> commandResultCompletableFuture = testUnit.executeAsync(noParameters);
|
||||
CommandTestUtilities.checkSuccessfulCompletionAsync(commandResultCompletableFuture);
|
||||
List<FeatureModeDisplay> usedDisplays = modelCaptor.getValue().getFeatureModes();
|
||||
Assert.assertEquals(featureModeDisplays.size(), usedDisplays.size());
|
||||
Assert.assertEquals(featureModeDisplays, usedDisplays);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExecuteFeatureParameter() {
|
||||
CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(FEATURE_NAME));
|
||||
FeatureModeDisplay display1 = Mockito.mock(FeatureModeDisplay.class);
|
||||
FeatureEnum featureEnum = Mockito.mock(FeatureEnum.class);
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureConfigService.getFeatureEnum(FEATURE_NAME)).thenReturn(featureEnum);
|
||||
AFeature feature = Mockito.mock(AFeature.class);
|
||||
when(featureManagementService.getFeature(FEATURE_NAME)).thenReturn(feature);
|
||||
List<FeatureModeDisplay> featureModeDisplays = Arrays.asList(display1);
|
||||
when(featureModeService.getEffectiveFeatureModes(noParameters.getUserInitiatedContext().getServer(), feature)).thenReturn(featureModeDisplays);
|
||||
when(channelService.sendEmbedTemplateInChannel(eq(FeatureModes.FEATURE_MODES_RESPONSE_TEMPLATE_KEY), modelCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(new ArrayList<>());
|
||||
CompletableFuture<CommandResult> commandResultCompletableFuture = testUnit.executeAsync(noParameters);
|
||||
CommandTestUtilities.checkSuccessfulCompletionAsync(commandResultCompletableFuture);
|
||||
List<FeatureModeDisplay> usedDisplays = modelCaptor.getValue().getFeatureModes();
|
||||
Assert.assertEquals(featureModeDisplays.size(), usedDisplays.size());
|
||||
Assert.assertEquals(featureModeDisplays, usedDisplays);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureNotFoundException.class)
|
||||
public void testExecuteDisableNotExistingFeature() {
|
||||
when(featureConfigService.getFeatureEnum(FEATURE_NAME)).thenThrow(new FeatureNotFoundException(FEATURE_NAME, new ArrayList<>()));
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(FEATURE_NAME));
|
||||
testUnit.executeAsync(context);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package dev.sheldan.abstracto.core.listener;
|
||||
|
||||
import dev.sheldan.abstracto.core.models.database.AFeature;
|
||||
import dev.sheldan.abstracto.core.models.database.AFeatureFlag;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.DefaultFeatureFlag;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultFeatureFlagManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.FeatureFlagManagementService;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class FeatureFlagListenerTest {
|
||||
|
||||
@InjectMocks
|
||||
private FeatureFlagListener testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureFlagManagementService service;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureFlagManagementService defaultFeatureFlagManagementService;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureFlag defaultFeatureFlag1;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureFlag defaultFeatureFlag2;
|
||||
|
||||
@Mock
|
||||
private AFeature aFeature1;
|
||||
|
||||
@Mock
|
||||
private AFeature aFeature2;
|
||||
|
||||
@Mock
|
||||
private AServer server;
|
||||
|
||||
@Mock
|
||||
private AFeatureFlag aFeatureFlag;
|
||||
|
||||
private static final Long SERVER_ID = 8L;
|
||||
|
||||
@Test
|
||||
public void testCreateMultipleOneAlreadyExisting() {
|
||||
when(server.getId()).thenReturn(SERVER_ID);
|
||||
when(defaultFeatureFlagManagementService.getAllDefaultFeatureFlags()).thenReturn(Arrays.asList(defaultFeatureFlag1, defaultFeatureFlag2));
|
||||
when(defaultFeatureFlag1.getFeature()).thenReturn(aFeature1);
|
||||
when(defaultFeatureFlag2.getFeature()).thenReturn(aFeature2);
|
||||
when(defaultFeatureFlag2.isEnabled()).thenReturn(true);
|
||||
when(service.featureFlagExists(aFeature1, server)).thenReturn(true);
|
||||
when(service.featureFlagExists(aFeature2, server)).thenReturn(false);
|
||||
when(service.createFeatureFlag(aFeature2, SERVER_ID, true)).thenReturn(aFeatureFlag);
|
||||
testUnit.updateServerConfig(server);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
package dev.sheldan.abstracto.core.service;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.service.management.FeatureManagementService;
|
||||
import dev.sheldan.abstracto.core.config.FeatureConfig;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.config.FeatureMode;
|
||||
import dev.sheldan.abstracto.core.models.database.*;
|
||||
import dev.sheldan.abstracto.core.models.template.commands.FeatureModeDisplay;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultFeatureModeManagement;
|
||||
import dev.sheldan.abstracto.core.service.management.FeatureFlagManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.FeatureModeManagementService;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class FeatureModeServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private FeatureModeServiceBean testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Mock
|
||||
private FeatureFlagManagementService featureFlagManagementService;
|
||||
|
||||
@Mock
|
||||
private FeatureManagementService featureManagementService;
|
||||
|
||||
@Mock
|
||||
private FeatureModeManagementService featureModeManagementService;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureModeManagement defaultFeatureModeManagement;
|
||||
|
||||
@Mock
|
||||
private FeatureMode featureMode;
|
||||
|
||||
@Mock
|
||||
private AFeatureMode aFeatureMode;
|
||||
|
||||
@Mock
|
||||
private AServer server;
|
||||
|
||||
@Mock
|
||||
private FeatureEnum featureEnum;
|
||||
|
||||
@Mock
|
||||
private AFeature feature;
|
||||
|
||||
@Mock
|
||||
private AFeatureFlag featureFlag;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureMode defaultFeatureMode;
|
||||
|
||||
@Mock
|
||||
private FeatureConfig featureConfig;
|
||||
|
||||
private static final String FEATURE_NAME = "feature";
|
||||
private static final String FEATURE_MODE = "mode";
|
||||
|
||||
@Test
|
||||
public void enableFeatureModeForFeatureWhichAlreadyExists() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.enableFeatureModeForFeature(featureEnum, server, featureMode);
|
||||
verify(aFeatureMode, times(1)).setEnabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void enableFeatureModeForFeatureCreatingNewMode() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.empty());
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(featureFlag);
|
||||
testUnit.enableFeatureModeForFeature(featureEnum, server, featureMode);
|
||||
verify(featureModeManagementService, times(1)).createMode(featureFlag, featureMode, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setFutureModeForFutureEnable() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.setFutureModeForFuture(featureEnum, server, featureMode, true);
|
||||
verify(aFeatureMode, times(1)).setEnabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setFutureModeForFutureDisable() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.setFutureModeForFuture(featureEnum, server, featureMode, false);
|
||||
verify(aFeatureMode, times(1)).setEnabled(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void disableFeatureModeForFeatureWhichAlreadyExists() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.disableFeatureModeForFeature(featureEnum, server, featureMode);
|
||||
verify(aFeatureMode, times(1)).setEnabled(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void disableFeatureModeForFeatureCreatingNewMode() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.empty());
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(featureFlag);
|
||||
testUnit.disableFeatureModeForFeature(featureEnum, server, featureMode);
|
||||
verify(featureModeManagementService, times(1)).createMode(featureFlag, featureMode, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureModeActiveForCustomizedFeatureMode() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.doesFeatureModeExist(feature, server, featureMode)).thenReturn(true);
|
||||
when(featureModeManagementService.isFeatureModeActive(feature, server, featureMode)).thenReturn(true);
|
||||
boolean actualResult = testUnit.featureModeActive(featureEnum, server, featureMode);
|
||||
Assert.assertTrue(actualResult);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureModeActiveForDefaultFeatureMode() {
|
||||
when(featureEnum.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(featureManagementService.getFeature(featureEnum.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.doesFeatureModeExist(feature, server, featureMode)).thenReturn(false);
|
||||
when(defaultFeatureModeManagement.getFeatureMode(feature, FEATURE_MODE)).thenReturn(defaultFeatureMode);
|
||||
when(defaultFeatureMode.isEnabled()).thenReturn(true);
|
||||
boolean actualResult = testUnit.featureModeActive(featureEnum, server, featureMode);
|
||||
Assert.assertTrue(actualResult);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureModeForKey() {
|
||||
FeatureConfig featureConfig1 = Mockito.mock(FeatureConfig.class);
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
FeatureMode featureMode2 = Mockito.mock(FeatureMode.class);
|
||||
when(featureConfig1.getAvailableModes()).thenReturn(Arrays.asList(featureMode, featureMode2));
|
||||
when(featureConfigService.getAllFeatureConfigs()).thenReturn(Arrays.asList(featureConfig1));
|
||||
FeatureMode featureModeForKey = testUnit.getFeatureModeForKey(FEATURE_MODE);
|
||||
Assert.assertEquals(featureMode, featureModeForKey);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAllAvailableFeatureModes() {
|
||||
FeatureConfig featureConfig1 = Mockito.mock(FeatureConfig.class);
|
||||
FeatureMode featureMode2 = Mockito.mock(FeatureMode.class);
|
||||
when(featureConfig1.getAvailableModes()).thenReturn(Arrays.asList(featureMode, featureMode2));
|
||||
FeatureConfig featureConfig2 = Mockito.mock(FeatureConfig.class);
|
||||
FeatureMode featureMode3 = Mockito.mock(FeatureMode.class);
|
||||
FeatureMode featureMode4 = Mockito.mock(FeatureMode.class);
|
||||
when(featureConfig2.getAvailableModes()).thenReturn(Arrays.asList(featureMode3, featureMode4));
|
||||
when(featureConfigService.getAllFeatureConfigs()).thenReturn(Arrays.asList(featureConfig1, featureConfig2));
|
||||
List<FeatureMode> allAvailableFeatureModes = testUnit.getAllAvailableFeatureModes();
|
||||
Assert.assertEquals(4, allAvailableFeatureModes.size());
|
||||
Assert.assertEquals(featureMode, allAvailableFeatureModes.get(0));
|
||||
Assert.assertEquals(featureMode2, allAvailableFeatureModes.get(1));
|
||||
Assert.assertEquals(featureMode3, allAvailableFeatureModes.get(2));
|
||||
Assert.assertEquals(featureMode4, allAvailableFeatureModes.get(3));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEffectiveFeatureModesOnlyOneDefault() {
|
||||
when(defaultFeatureMode.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureMode.isEnabled()).thenReturn(true);
|
||||
when(defaultFeatureMode.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureConfigForFeature(feature)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfServer(server)).thenReturn(new ArrayList<>());
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(featureFlag);
|
||||
List<FeatureModeDisplay> effectiveFeatureModes = testUnit.getEffectiveFeatureModes(server);
|
||||
Assert.assertEquals(1, effectiveFeatureModes.size());
|
||||
FeatureModeDisplay featureModeDisplay = effectiveFeatureModes.get(0);
|
||||
Assert.assertEquals(true, featureModeDisplay.getIsDefaultValue());
|
||||
Assert.assertTrue(featureModeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, featureModeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, featureModeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(defaultFeatureMode, featureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay.getFeatureConfig());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEffectiveFeatureModesOnlyOneCustomized() {
|
||||
when(aFeatureMode.getEnabled()).thenReturn(true);
|
||||
when(aFeatureMode.getFeatureFlag()).thenReturn(featureFlag);
|
||||
when(aFeatureMode.getServer()).thenReturn(server);
|
||||
when(aFeatureMode.getFeatureMode()).thenReturn(defaultFeatureMode);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureConfigForFeature(feature)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfServer(server)).thenReturn(Arrays.asList(aFeatureMode));
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
List<FeatureModeDisplay> effectiveFeatureModes = testUnit.getEffectiveFeatureModes(server);
|
||||
Assert.assertEquals(1, effectiveFeatureModes.size());
|
||||
FeatureModeDisplay featureModeDisplay = effectiveFeatureModes.get(0);
|
||||
Assert.assertEquals(false, featureModeDisplay.getIsDefaultValue());
|
||||
Assert.assertTrue(featureModeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, featureModeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, featureModeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(defaultFeatureMode, featureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay.getFeatureConfig());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEffectiveFeatureModesMixed() {
|
||||
when(aFeatureMode.getEnabled()).thenReturn(true);
|
||||
when(aFeatureMode.getFeatureFlag()).thenReturn(featureFlag);
|
||||
when(aFeatureMode.getServer()).thenReturn(server);
|
||||
when(aFeatureMode.getFeatureMode()).thenReturn(defaultFeatureMode);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
DefaultFeatureMode defaultFeatureMode2 = Mockito.mock(DefaultFeatureMode.class);
|
||||
when(defaultFeatureMode2.getMode()).thenReturn("SECOND");
|
||||
when(defaultFeatureMode2.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureMode2.isEnabled()).thenReturn(false);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode2, defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureConfigForFeature(feature)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfServer(server)).thenReturn(Arrays.asList(aFeatureMode));
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(featureFlag);
|
||||
|
||||
List<FeatureModeDisplay> effectiveFeatureModes = testUnit.getEffectiveFeatureModes(server);
|
||||
|
||||
Assert.assertEquals(2, effectiveFeatureModes.size());
|
||||
FeatureModeDisplay featureModeDisplay = effectiveFeatureModes.get(0);
|
||||
Assert.assertEquals(false, featureModeDisplay.getIsDefaultValue());
|
||||
Assert.assertTrue(featureModeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, featureModeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, featureModeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(defaultFeatureMode, featureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay.getFeatureConfig());
|
||||
|
||||
FeatureModeDisplay featureModeDisplay2 = effectiveFeatureModes.get(1);
|
||||
Assert.assertEquals(true, featureModeDisplay2.getIsDefaultValue());
|
||||
Assert.assertFalse(featureModeDisplay2.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, featureModeDisplay2.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, featureModeDisplay2.getFeatureMode().getServer());
|
||||
Assert.assertEquals(defaultFeatureMode2, featureModeDisplay2.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay2.getFeatureConfig());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetEffectiveFeatureModesForFeature() {
|
||||
when(defaultFeatureMode.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureMode.isEnabled()).thenReturn(true);
|
||||
when(defaultFeatureMode.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureModeManagement.getFeatureModesForFeature(feature)).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureConfigForFeature(feature)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfFeatureInServer(server, feature)).thenReturn(new ArrayList<>());
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(featureFlag);
|
||||
List<FeatureModeDisplay> effectiveFeatureModes = testUnit.getEffectiveFeatureModes(server, feature);
|
||||
Assert.assertEquals(1, effectiveFeatureModes.size());
|
||||
FeatureModeDisplay featureModeDisplay = effectiveFeatureModes.get(0);
|
||||
Assert.assertEquals(true, featureModeDisplay.getIsDefaultValue());
|
||||
Assert.assertTrue(featureModeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, featureModeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, featureModeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(defaultFeatureMode, featureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay.getFeatureConfig());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package dev.sheldan.abstracto.core.service.management;
|
||||
|
||||
import dev.sheldan.abstracto.core.exception.FeatureModeNotFoundException;
|
||||
import dev.sheldan.abstracto.core.models.database.AFeature;
|
||||
import dev.sheldan.abstracto.core.models.database.DefaultFeatureMode;
|
||||
import dev.sheldan.abstracto.core.repository.DefaultFeatureModeRepository;
|
||||
import dev.sheldan.abstracto.core.service.FeatureConfigService;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class DefaultFeatureModeManagementBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private DefaultFeatureModeManagementBean testUnit;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureModeRepository defaultFeatureModeRepository;
|
||||
|
||||
@Mock
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Mock
|
||||
private AFeature feature;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureMode defaultFeatureMode1;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureMode defaultFeatureMode2;
|
||||
|
||||
private static final String MODE_NAME = "mode";
|
||||
|
||||
@Test
|
||||
public void getFeatureModesForFeature() {
|
||||
List<DefaultFeatureMode> defaultFeatureModes = Arrays.asList(defaultFeatureMode1, defaultFeatureMode2);
|
||||
when(defaultFeatureModeRepository.findByFeature(feature)).thenReturn(defaultFeatureModes);
|
||||
List<DefaultFeatureMode> featureModesForFeature = testUnit.getFeatureModesForFeature(feature);
|
||||
Assert.assertEquals(defaultFeatureModes.size(), featureModesForFeature.size());
|
||||
Assert.assertEquals(defaultFeatureModes, featureModesForFeature);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAll() {
|
||||
List<DefaultFeatureMode> defaultFeatureModes = Arrays.asList(defaultFeatureMode1, defaultFeatureMode2);
|
||||
when(defaultFeatureModeRepository.findAll()).thenReturn(defaultFeatureModes);
|
||||
List<DefaultFeatureMode> featureModesForFeature = testUnit.getAll();
|
||||
Assert.assertEquals(defaultFeatureModes.size(), featureModesForFeature.size());
|
||||
Assert.assertEquals(defaultFeatureModes, featureModesForFeature);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureModeOptional() {
|
||||
when(defaultFeatureModeRepository.findByFeatureAndMode(feature, MODE_NAME)).thenReturn(Optional.of(defaultFeatureMode1));
|
||||
Optional<DefaultFeatureMode> featureModeOptional = testUnit.getFeatureModeOptional(feature, MODE_NAME);
|
||||
Assert.assertTrue(featureModeOptional.isPresent());
|
||||
featureModeOptional.ifPresent(defaultFeatureMode ->
|
||||
Assert.assertEquals(defaultFeatureMode1, defaultFeatureMode)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureModeOptionalNotExisting() {
|
||||
when(defaultFeatureModeRepository.findByFeatureAndMode(feature, MODE_NAME)).thenReturn(Optional.empty());
|
||||
Optional<DefaultFeatureMode> featureModeOptional = testUnit.getFeatureModeOptional(feature, MODE_NAME);
|
||||
Assert.assertFalse(featureModeOptional.isPresent());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureMode() {
|
||||
when(defaultFeatureModeRepository.findByFeatureAndMode(feature, MODE_NAME)).thenReturn(Optional.of(defaultFeatureMode1));
|
||||
DefaultFeatureMode defaultFeatureMode = testUnit.getFeatureMode(feature, MODE_NAME);
|
||||
Assert.assertEquals(defaultFeatureMode1, defaultFeatureMode);
|
||||
}
|
||||
|
||||
@Test(expected = FeatureModeNotFoundException.class)
|
||||
public void getFeatureModeNotExisting() {
|
||||
when(defaultFeatureModeRepository.findByFeatureAndMode(feature, MODE_NAME)).thenReturn(Optional.empty());
|
||||
testUnit.getFeatureMode(feature, MODE_NAME);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
package dev.sheldan.abstracto.core.service.management;
|
||||
|
||||
import dev.sheldan.abstracto.core.config.FeatureMode;
|
||||
import dev.sheldan.abstracto.core.models.database.*;
|
||||
import dev.sheldan.abstracto.core.repository.FeatureModeRepository;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class FeatureModeManagementServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private FeatureModeManagementServiceBean testUnit;
|
||||
|
||||
@Mock
|
||||
private FeatureModeRepository featureModeRepository;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureModeManagement defaultFeatureModeManagement;
|
||||
|
||||
@Mock
|
||||
private AFeature feature;
|
||||
|
||||
@Mock
|
||||
private DefaultFeatureMode defaultFeatureMode;
|
||||
|
||||
@Mock
|
||||
private AFeatureFlag featureFlag;
|
||||
|
||||
@Mock
|
||||
private AServer server;
|
||||
|
||||
@Mock
|
||||
private FeatureMode featureMode;
|
||||
|
||||
@Mock
|
||||
private AFeatureMode aFeatureMode;
|
||||
|
||||
private static final String FEATURE_MODE = "featureMode";
|
||||
|
||||
@Test
|
||||
public void createModeWithModeAsString() {
|
||||
when(featureFlag.getServer()).thenReturn(server);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
when(defaultFeatureModeManagement.getFeatureMode(feature, FEATURE_MODE)).thenReturn(defaultFeatureMode);
|
||||
AFeatureMode createdMode = testUnit.createMode(featureFlag, FEATURE_MODE, true);
|
||||
Assert.assertEquals(true, createdMode.getEnabled());
|
||||
Assert.assertEquals(featureFlag, createdMode.getFeatureFlag());
|
||||
Assert.assertEquals(defaultFeatureMode, createdMode.getFeatureMode());
|
||||
Assert.assertEquals(server, createdMode.getServer());
|
||||
verify(featureModeRepository, times(1)).save(createdMode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateMode() {
|
||||
when(featureFlag.getServer()).thenReturn(server);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(defaultFeatureModeManagement.getFeatureMode(feature, FEATURE_MODE)).thenReturn(defaultFeatureMode);
|
||||
AFeatureMode createdMode = testUnit.createMode(featureFlag, featureMode, true);
|
||||
Assert.assertEquals(true, createdMode.getEnabled());
|
||||
Assert.assertEquals(featureFlag, createdMode.getFeatureFlag());
|
||||
Assert.assertEquals(defaultFeatureMode, createdMode.getFeatureMode());
|
||||
Assert.assertEquals(server, createdMode.getServer());
|
||||
verify(featureModeRepository, times(1)).save(createdMode);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeActive() {
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(aFeatureMode.getEnabled()).thenReturn(true);
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.of(aFeatureMode));
|
||||
Assert.assertTrue(testUnit.isFeatureModeActive(feature, server, featureMode));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeNotActive() {
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(aFeatureMode.getEnabled()).thenReturn(false);
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.of(aFeatureMode));
|
||||
Assert.assertFalse(testUnit.isFeatureModeActive(feature, server, featureMode));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeNotPresent() {
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.empty());
|
||||
Assert.assertFalse(testUnit.isFeatureModeActive(feature, server, featureMode));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeStringExists() {
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.of(aFeatureMode));
|
||||
Assert.assertTrue(testUnit.doesFeatureModeExist(feature, server, FEATURE_MODE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeObjectExists() {
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.of(aFeatureMode));
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
Assert.assertTrue(testUnit.doesFeatureModeExist(feature, server, featureMode));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void featureModeDoesNotExist() {
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.empty());
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
Assert.assertFalse(testUnit.doesFeatureModeExist(feature, server, featureMode));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetFeatureModeOptional() {
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.of(aFeatureMode));
|
||||
Optional<AFeatureMode> featureModeOptional = testUnit.getFeatureMode(feature, server, FEATURE_MODE);
|
||||
Assert.assertTrue(featureModeOptional.isPresent());
|
||||
featureModeOptional.ifPresent(aFeatureMode1 ->
|
||||
Assert.assertEquals(aFeatureMode, aFeatureMode1)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetFeatureModeOptionalNotExisting() {
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_FeatureAndFeatureMode_Mode(server, feature, FEATURE_MODE)).thenReturn(Optional.empty());
|
||||
Optional<AFeatureMode> featureModeOptional = testUnit.getFeatureMode(feature, server, FEATURE_MODE);
|
||||
Assert.assertFalse(featureModeOptional.isPresent());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureModesOfServer() {
|
||||
List<AFeatureMode> expected = Arrays.asList(aFeatureMode, aFeatureMode);
|
||||
when(featureModeRepository.findByServer(server)).thenReturn(expected);
|
||||
List<AFeatureMode> featureModesOfServer = testUnit.getFeatureModesOfServer(server);
|
||||
Assert.assertEquals(expected, featureModesOfServer);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFeatureModesOfFeatureInServer() {
|
||||
List<AFeatureMode> expected = Arrays.asList(aFeatureMode);
|
||||
when(featureModeRepository.findByServerAndFeatureFlag_Feature(server, feature)).thenReturn(expected);
|
||||
List<AFeatureMode> featureModesOfServer = testUnit.getFeatureModesOfFeatureInServer(server, feature);
|
||||
Assert.assertEquals(expected, featureModesOfServer);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user