mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-03-27 14:23:56 +00:00
[AB-52] upgrading to alpha 12
adding anonymous reporting reworking message context commands refactoring interaction packages adding post execution handling for message context commands and modals reworking feature mode response fixing setup using component ids storing infraction parameters, for example mute duration, with every infraction adding infractions for more moderation actions creating general method to format a duration string adding infractions command reworking muting to use built-in functionality of discord enabling chunking of members removing manual unmuting feature mode adding ability to update infractions with a command implemented infraction listeners for ban and warn refactored infraction notifications storing log messages to the infraction for editing said log messages
This commit is contained in:
Sheldan
@@ -1,311 +0,0 @@
|
||||
package dev.sheldan.abstracto.core.command;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
|
||||
import dev.sheldan.abstracto.core.command.config.Parameter;
|
||||
import dev.sheldan.abstracto.core.command.config.Parameters;
|
||||
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
|
||||
import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
|
||||
import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
|
||||
import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
|
||||
import dev.sheldan.abstracto.core.command.service.CommandManager;
|
||||
import dev.sheldan.abstracto.core.command.service.CommandService;
|
||||
import dev.sheldan.abstracto.core.command.service.ExceptionService;
|
||||
import dev.sheldan.abstracto.core.command.service.PostCommandExecution;
|
||||
import dev.sheldan.abstracto.core.metric.service.MetricService;
|
||||
import dev.sheldan.abstracto.core.service.EmoteService;
|
||||
import dev.sheldan.abstracto.core.service.RoleService;
|
||||
import dev.sheldan.abstracto.core.service.management.*;
|
||||
import net.dv8tion.jda.api.entities.*;
|
||||
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
|
||||
import org.apache.commons.collections4.Bag;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.*;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
import org.springframework.context.annotation.Lazy;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class CommandReceivedHandlerTest {
|
||||
|
||||
@InjectMocks
|
||||
private CommandReceivedHandler testUnit;
|
||||
|
||||
@Mock
|
||||
private CommandManager commandManager;
|
||||
|
||||
@Mock
|
||||
private List<PostCommandExecution> executions;
|
||||
|
||||
@Mock
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
|
||||
@Mock
|
||||
private ChannelManagementService channelManagementService;
|
||||
|
||||
@Mock
|
||||
@Lazy
|
||||
private CommandReceivedHandler self;
|
||||
|
||||
@Mock
|
||||
private RoleManagementService roleManagementService;
|
||||
|
||||
@Mock
|
||||
private CommandService commandService;
|
||||
|
||||
@Mock
|
||||
private EmoteService emoteService;
|
||||
|
||||
@Mock
|
||||
private ExceptionService exceptionService;
|
||||
|
||||
@Mock
|
||||
private EmoteManagementService emoteManagementService;
|
||||
|
||||
@Mock
|
||||
private RoleService roleService;
|
||||
|
||||
@Spy
|
||||
private List<CommandParameterHandler> parameterHandlers = new ArrayList<>();
|
||||
|
||||
@Mock
|
||||
private MetricService metricService;
|
||||
|
||||
@Mock
|
||||
private MessageReceivedEvent event;
|
||||
|
||||
@Mock
|
||||
private Message message;
|
||||
|
||||
@Mock
|
||||
private Guild guild;
|
||||
|
||||
@Mock
|
||||
private Command command;
|
||||
|
||||
@Mock
|
||||
private MessageChannel channel;
|
||||
|
||||
@Captor
|
||||
private ArgumentCaptor<Parameters> parametersArgumentCaptor;
|
||||
|
||||
@Mock
|
||||
private CommandParameterHandler parameterHandler;
|
||||
|
||||
@Mock
|
||||
private CommandParameterHandler secondParameterHandler;
|
||||
|
||||
@Mock
|
||||
private CommandConfiguration commandConfiguration;
|
||||
|
||||
@Mock
|
||||
private Parameter parameter;
|
||||
|
||||
@Mock
|
||||
private Parameter secondParameter;
|
||||
|
||||
@Mock
|
||||
private Bag<Emote> emotes;
|
||||
|
||||
@Mock
|
||||
private List<Member> members;
|
||||
|
||||
@Mock
|
||||
private Member member;
|
||||
|
||||
@Mock
|
||||
private Bag<Role> roles;
|
||||
|
||||
private static final String COMMAND_NAME = "command";
|
||||
private static final String MESSAGE_CONTENT_COMMAND_ONLY = "message";
|
||||
public static final String PARAMETER_TEXT_1 = "param1";
|
||||
public static final String PARAMETER_TEXT_2 = "param2";
|
||||
private static final String MESSAGE_CONTENT_ONE_PARAMETER = MESSAGE_CONTENT_COMMAND_ONLY + " " + PARAMETER_TEXT_1;
|
||||
private static final String MESSAGE_CONTENT_TWO_PARAMETER = MESSAGE_CONTENT_COMMAND_ONLY + " " + PARAMETER_TEXT_1 + " " + PARAMETER_TEXT_2;
|
||||
private static final Long SERVER_ID = 1L;
|
||||
|
||||
@Before
|
||||
public void init() {
|
||||
MockitoAnnotations.initMocks(this);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNotFromGuild() {
|
||||
when(event.isFromGuild()).thenReturn(false);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(commandManager, times(0)).isCommand(any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNotACommandMessage() {
|
||||
when(event.isFromGuild()).thenReturn(true);
|
||||
when(event.getMessage()).thenReturn(message);
|
||||
when(commandManager.isCommand(message)).thenReturn(false);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(metricService, times(0)).incrementCounter(any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCommandNotFoundException() {
|
||||
when(event.isFromGuild()).thenReturn(true);
|
||||
when(event.getMessage()).thenReturn(message);
|
||||
when(commandManager.isCommand(message)).thenReturn(true);
|
||||
when(event.getGuild()).thenReturn(guild);
|
||||
when(event.getChannel()).thenReturn(channel);
|
||||
when(event.getMember()).thenReturn(member);
|
||||
when(message.getGuild()).thenReturn(guild);
|
||||
when(guild.getIdLong()).thenReturn(SERVER_ID);
|
||||
when(message.getContentRaw()).thenReturn(MESSAGE_CONTENT_COMMAND_ONLY);
|
||||
when(commandManager.getCommandName(anyString(), eq(SERVER_ID))).thenReturn(COMMAND_NAME);
|
||||
when(commandManager.findCommandByParameters(eq(COMMAND_NAME), any(), eq(SERVER_ID))).thenThrow(new CommandNotFoundException());
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executePostCommandListener(any(), any(), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseDurationParameter() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_ONE_PARAMETER);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter));
|
||||
when(parameter.getType()).thenReturn(Duration.class);
|
||||
Duration parsedDuration = Duration.ofMinutes(1);
|
||||
when(parameterHandler.handles(eq(Duration.class), any())).thenReturn(true);
|
||||
when(parameterHandler.handle(any(UnparsedCommandParameterPiece.class), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(parsedDuration);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(1, parameters.size());
|
||||
Assert.assertEquals(parsedDuration, parameters.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseStringParameter() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_ONE_PARAMETER);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter));
|
||||
when(parameter.getType()).thenReturn(String.class);
|
||||
when(parameterHandler.handles(eq(String.class), any())).thenReturn(true);
|
||||
when(parameterHandler.handle(any(UnparsedCommandParameterPiece.class), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(PARAMETER_TEXT_1);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(1, parameters.size());
|
||||
Assert.assertEquals(PARAMETER_TEXT_1, parameters.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseStringRemainderParameter() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_TWO_PARAMETER);
|
||||
when(parameter.isRemainder()).thenReturn(true);
|
||||
when(parameter.getType()).thenReturn(String.class);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter));
|
||||
when(parameterHandler.handles(eq(String.class), any())).thenReturn(true);
|
||||
when(parameterHandler.handle(argThat(parameterPieceMatcher(PARAMETER_TEXT_1)), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(PARAMETER_TEXT_1);
|
||||
when(parameterHandler.handle(argThat(parameterPieceMatcher(PARAMETER_TEXT_2)), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(PARAMETER_TEXT_2);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(1, parameters.size());
|
||||
Assert.assertEquals(PARAMETER_TEXT_1 + " " + PARAMETER_TEXT_2, parameters.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseDurationAndStringRemainderParameter() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_TWO_PARAMETER);
|
||||
when(parameter.isRemainder()).thenReturn(false);
|
||||
when(parameter.getType()).thenReturn(Duration.class);
|
||||
when(secondParameter.getType()).thenReturn(String.class);
|
||||
when(secondParameter.isRemainder()).thenReturn(true);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter, secondParameter));
|
||||
when(parameterHandler.handles(eq(Duration.class), any())).thenReturn(true);
|
||||
when(secondParameterHandler.handles(eq(String.class), any())).thenReturn(true);
|
||||
Duration parsedDuration = Duration.ofMinutes(1);
|
||||
when(parameterHandler.handle(argThat(parameterPieceMatcher(PARAMETER_TEXT_1)), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(parsedDuration);
|
||||
when(secondParameterHandler.handle(argThat(parameterPieceMatcher(PARAMETER_TEXT_2)), any(CommandParameterIterators.class), eq(secondParameter), eq(message), eq(command))).thenReturn(PARAMETER_TEXT_2);
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(2, parameters.size());
|
||||
Assert.assertEquals(parsedDuration, parameters.get(0));
|
||||
Assert.assertEquals(PARAMETER_TEXT_2, parameters.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseWithAsyncParameterHandler() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_TWO_PARAMETER);
|
||||
when(parameter.getType()).thenReturn(Duration.class);
|
||||
when(parameter.isRemainder()).thenReturn(false);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter, secondParameter));
|
||||
when(parameterHandler.handles(eq(Duration.class), any())).thenReturn(true);
|
||||
when(parameterHandler.async()).thenReturn(true);
|
||||
Duration parsedDuration = Duration.ofMinutes(1);
|
||||
when(parameterHandler.handleAsync(argThat(parameterPieceMatcher(PARAMETER_TEXT_1)), any(CommandParameterIterators.class),
|
||||
eq(parameter), eq(message), eq(command))).thenReturn(CompletableFuture.completedFuture(parsedDuration));
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(1, parameters.size());
|
||||
Assert.assertEquals(parsedDuration, parameters.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseDurationAndStringRemainderParameterAsyncMixed() {
|
||||
setupCommandAndMessage(MESSAGE_CONTENT_TWO_PARAMETER);
|
||||
when(parameter.isRemainder()).thenReturn(false);
|
||||
when(parameter.getType()).thenReturn(Duration.class);
|
||||
when(secondParameter.getType()).thenReturn(String.class);
|
||||
when(secondParameter.isRemainder()).thenReturn(true);
|
||||
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter, secondParameter));
|
||||
when(parameterHandler.handles(eq(Duration.class), any())).thenReturn(true);
|
||||
when(secondParameterHandler.handles(eq(String.class), any())).thenReturn(true);
|
||||
when(secondParameterHandler.async()).thenReturn(true);
|
||||
Duration parsedDuration = Duration.ofMinutes(1);
|
||||
when(parameterHandler.handle(argThat(parameterPieceMatcher(PARAMETER_TEXT_1)), any(CommandParameterIterators.class), eq(parameter), eq(message), eq(command))).thenReturn(parsedDuration);
|
||||
when(secondParameterHandler.handleAsync(argThat(parameterPieceMatcher(PARAMETER_TEXT_2)),
|
||||
any(CommandParameterIterators.class), eq(secondParameter), eq(message), eq(command))).thenReturn(CompletableFuture.completedFuture(PARAMETER_TEXT_2));
|
||||
testUnit.onMessageReceived(event);
|
||||
verify(self, times(1)).executeCommand(eq(event), eq(command), parametersArgumentCaptor.capture());
|
||||
Parameters usedParameters = parametersArgumentCaptor.getValue();
|
||||
List<Object> parameters = usedParameters.getParameters();
|
||||
Assert.assertEquals(2, parameters.size());
|
||||
Assert.assertEquals(parsedDuration, parameters.get(0));
|
||||
Assert.assertEquals(PARAMETER_TEXT_2, parameters.get(1));
|
||||
}
|
||||
|
||||
private void setupCommandAndMessage(String messageContentTwoParameter) {
|
||||
parameterHandlers.add(parameterHandler);
|
||||
parameterHandlers.add(secondParameterHandler);
|
||||
when(event.isFromGuild()).thenReturn(true);
|
||||
when(message.getGuild()).thenReturn(guild);
|
||||
when(event.getMessage()).thenReturn(message);
|
||||
when(commandManager.isCommand(message)).thenReturn(true);
|
||||
when(guild.getIdLong()).thenReturn(SERVER_ID);
|
||||
when(message.getContentRaw()).thenReturn(messageContentTwoParameter);
|
||||
when(commandManager.getCommandName(anyString(), eq(SERVER_ID))).thenReturn(COMMAND_NAME);
|
||||
when(commandManager.findCommandByParameters(eq(COMMAND_NAME), any(), eq(SERVER_ID))).thenReturn(command);
|
||||
when(command.getConfiguration()).thenReturn(commandConfiguration);
|
||||
when(message.getEmotesBag()).thenReturn(emotes);
|
||||
when(message.getMentionedMembers()).thenReturn(members);
|
||||
when(message.getMentionedRolesBag()).thenReturn(roles);
|
||||
}
|
||||
|
||||
private ArgumentMatcher<UnparsedCommandParameterPiece> parameterPieceMatcher(Object value) {
|
||||
return argument -> argument != null && value.equals(argument.getValue());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.core.command.service;
|
||||
import dev.sheldan.abstracto.core.command.Command;
|
||||
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
|
||||
import dev.sheldan.abstracto.core.command.config.Parameter;
|
||||
import dev.sheldan.abstracto.core.command.model.CommandServiceBean;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
|
||||
@@ -1,286 +0,0 @@
|
||||
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.FeatureDefinition;
|
||||
import dev.sheldan.abstracto.core.config.FeatureMode;
|
||||
import dev.sheldan.abstracto.core.models.database.*;
|
||||
import dev.sheldan.abstracto.core.models.property.FeatureModeProperty;
|
||||
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 FeatureDefinition featureDefinition;
|
||||
|
||||
@Mock
|
||||
private AFeature feature;
|
||||
|
||||
@Mock
|
||||
private AFeatureFlag featureFlag;
|
||||
|
||||
@Mock
|
||||
private FeatureModeProperty defaultFeatureMode;
|
||||
|
||||
@Mock
|
||||
private FeatureConfig featureConfig;
|
||||
|
||||
private static final String FEATURE_NAME = "feature";
|
||||
private static final String FEATURE_MODE = "mode";
|
||||
|
||||
@Test
|
||||
public void enableFeatureModeForFeatureWhichAlreadyExists() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.enableFeatureModeForFeature(featureDefinition, server, featureMode);
|
||||
verify(aFeatureMode, times(1)).setEnabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void enableFeatureModeForFeatureCreatingNewMode() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.empty());
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(Optional.of(featureFlag));
|
||||
testUnit.enableFeatureModeForFeature(featureDefinition, server, featureMode);
|
||||
verify(featureModeManagementService, times(1)).createMode(featureFlag, featureMode, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setFutureModeForFutureEnable() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.setFutureModeForFuture(featureDefinition, server, featureMode, true);
|
||||
verify(aFeatureMode, times(1)).setEnabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setFutureModeForFutureDisable() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.setFutureModeForFuture(featureDefinition, server, featureMode, false);
|
||||
verify(aFeatureMode, times(1)).setEnabled(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void disableFeatureModeForFeatureWhichAlreadyExists() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.of(aFeatureMode));
|
||||
testUnit.disableFeatureModeForFeature(featureDefinition, server, featureMode);
|
||||
verify(aFeatureMode, times(1)).setEnabled(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void disableFeatureModeForFeatureCreatingNewMode() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.getFeatureMode(feature, server, featureMode)).thenReturn(Optional.empty());
|
||||
when(featureFlagManagementService.getFeatureFlag(feature, server)).thenReturn(Optional.of(featureFlag));
|
||||
testUnit.disableFeatureModeForFeature(featureDefinition, server, featureMode);
|
||||
verify(featureModeManagementService, times(1)).createMode(featureFlag, featureMode, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureModeActiveForCustomizedFeatureMode() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.doesFeatureModeExist(feature, server, featureMode)).thenReturn(true);
|
||||
when(featureModeManagementService.isFeatureModeActive(feature, server, featureMode)).thenReturn(true);
|
||||
boolean actualResult = testUnit.featureModeActive(featureDefinition, server, featureMode);
|
||||
Assert.assertTrue(actualResult);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureModeActiveForDefaultFeatureMode() {
|
||||
when(featureDefinition.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
|
||||
when(featureManagementService.getFeature(featureDefinition.getKey())).thenReturn(feature);
|
||||
when(featureModeManagementService.doesFeatureModeExist(feature, server, featureMode)).thenReturn(false);
|
||||
when(defaultFeatureModeManagement.getFeatureMode(feature, FEATURE_MODE)).thenReturn(defaultFeatureMode);
|
||||
when(defaultFeatureMode.getEnabled()).thenReturn(true);
|
||||
boolean actualResult = testUnit.featureModeActive(featureDefinition, 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_NAME, 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.getEnabled()).thenReturn(true);
|
||||
when(defaultFeatureMode.getFeatureName()).thenReturn(FEATURE_NAME);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureDisplayForFeature(FEATURE_NAME)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfServer(server)).thenReturn(new ArrayList<>());
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(FEATURE_NAME, server)).thenReturn(Optional.of(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(FEATURE_MODE, 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(FEATURE_MODE);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
when(feature.getKey()).thenReturn(FEATURE_NAME);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureDisplayForFeature(FEATURE_NAME)).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(FEATURE_MODE, 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(FEATURE_MODE);
|
||||
when(featureFlag.getFeature()).thenReturn(feature);
|
||||
when(feature.getKey()).thenReturn(FEATURE_NAME);
|
||||
FeatureModeProperty defaultFeatureMode2 = Mockito.mock(FeatureModeProperty.class);
|
||||
String secondMode = "SECOND";
|
||||
when(defaultFeatureMode2.getMode()).thenReturn(secondMode);
|
||||
String feature2 = "FEATURE2";
|
||||
when(defaultFeatureMode2.getFeatureName()).thenReturn(feature2);
|
||||
when(defaultFeatureMode2.getEnabled()).thenReturn(false);
|
||||
when(defaultFeatureModeManagement.getAll()).thenReturn(Arrays.asList(defaultFeatureMode2, defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureDisplayForFeature(FEATURE_NAME)).thenReturn(featureConfig);
|
||||
when(featureConfigService.getFeatureDisplayForFeature(feature2)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfServer(server)).thenReturn(Arrays.asList(aFeatureMode));
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(feature2, server)).thenReturn(Optional.of(featureFlag));
|
||||
|
||||
List<FeatureModeDisplay> effectiveFeatureModes = testUnit.getEffectiveFeatureModes(server);
|
||||
|
||||
Assert.assertEquals(2, effectiveFeatureModes.size());
|
||||
FeatureModeDisplay activeFeaturemodeDisplay = effectiveFeatureModes.get(0);
|
||||
Assert.assertEquals(false, activeFeaturemodeDisplay.getIsDefaultValue());
|
||||
Assert.assertTrue(activeFeaturemodeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, activeFeaturemodeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, activeFeaturemodeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(FEATURE_MODE, activeFeaturemodeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, activeFeaturemodeDisplay.getFeatureConfig());
|
||||
|
||||
FeatureModeDisplay defaultFeatureModeDisplay = effectiveFeatureModes.get(1);
|
||||
Assert.assertEquals(true, defaultFeatureModeDisplay.getIsDefaultValue());
|
||||
Assert.assertFalse(defaultFeatureModeDisplay.getFeatureMode().getEnabled());
|
||||
Assert.assertEquals(featureFlag, defaultFeatureModeDisplay.getFeatureMode().getFeatureFlag());
|
||||
Assert.assertEquals(server, defaultFeatureModeDisplay.getFeatureMode().getServer());
|
||||
Assert.assertEquals(secondMode, defaultFeatureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, defaultFeatureModeDisplay.getFeatureConfig());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetEffectiveFeatureModesForFeature() {
|
||||
when(defaultFeatureMode.getEnabled()).thenReturn(true);
|
||||
when(defaultFeatureMode.getFeatureName()).thenReturn(FEATURE_NAME);
|
||||
when(defaultFeatureModeManagement.getFeatureModesForFeature(feature)).thenReturn(Arrays.asList(defaultFeatureMode));
|
||||
when(featureConfigService.getFeatureDisplayForFeature(FEATURE_NAME)).thenReturn(featureConfig);
|
||||
when(featureModeManagementService.getFeatureModesOfFeatureInServer(server, feature)).thenReturn(new ArrayList<>());
|
||||
when(defaultFeatureMode.getMode()).thenReturn(FEATURE_MODE);
|
||||
when(featureFlagManagementService.getFeatureFlag(FEATURE_NAME, server)).thenReturn(Optional.of(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(FEATURE_MODE, featureModeDisplay.getFeatureMode().getFeatureMode());
|
||||
Assert.assertEquals(featureConfig, featureModeDisplay.getFeatureConfig());
|
||||
}
|
||||
}
|
||||
@@ -1,126 +0,0 @@
|
||||
package dev.sheldan.abstracto.core.templating.method;
|
||||
|
||||
import dev.sheldan.abstracto.core.templating.service.TemplateService;
|
||||
import freemarker.ext.beans.StringModel;
|
||||
import freemarker.template.Configuration;
|
||||
import freemarker.template.DefaultObjectWrapper;
|
||||
import freemarker.template.DefaultObjectWrapperBuilder;
|
||||
import freemarker.template.TemplateModelException;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class DurationMethodTest {
|
||||
public static final long SECOND_AMOUNT = 10L;
|
||||
public static final long MINUTES_AMOUNT = 2L;
|
||||
public static final long HOURS_AMOUNT = 3L;
|
||||
public static final long DAYS_AMOUNT = 5L;
|
||||
public static final String DURATION_TEMPLATE = "duration_formatting";
|
||||
public static final String SECONDS = "seconds";
|
||||
public static final String HOURS = "hours";
|
||||
public static final String MINUTES = "minutes";
|
||||
public static final String DAYS = "days";
|
||||
|
||||
@InjectMocks
|
||||
private DurationMethod durationMethod;
|
||||
|
||||
@Mock
|
||||
private TemplateService templateService;
|
||||
|
||||
|
||||
@Test
|
||||
public void testSeconds() throws TemplateModelException {
|
||||
durationMethod.exec(getSecondParameters());
|
||||
verify(templateService, times(1)).renderTemplateWithMap(DURATION_TEMPLATE, getHashMap(0, 0, 0, SECOND_AMOUNT));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMinutes() throws TemplateModelException {
|
||||
durationMethod.exec(getMinuteParameter());
|
||||
verify(templateService, times(1)).renderTemplateWithMap(DURATION_TEMPLATE, getHashMap(0, 0, MINUTES_AMOUNT, 0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHours() throws TemplateModelException {
|
||||
durationMethod.exec(getHourParameter());
|
||||
verify(templateService, times(1)).renderTemplateWithMap(DURATION_TEMPLATE, getHashMap(0, HOURS_AMOUNT, 0, 0));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDays() throws TemplateModelException {
|
||||
durationMethod.exec(getDayParameter());
|
||||
verify(templateService, times(1)).renderTemplateWithMap(DURATION_TEMPLATE, getHashMap(DAYS_AMOUNT, 0, 0, 0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllTime() throws TemplateModelException {
|
||||
durationMethod.exec(getMixedParameter());
|
||||
verify(templateService, times(1)).renderTemplateWithMap(DURATION_TEMPLATE, getHashMap(DAYS_AMOUNT, HOURS_AMOUNT, MINUTES_AMOUNT, SECOND_AMOUNT));
|
||||
}
|
||||
|
||||
@Test(expected = TemplateModelException.class)
|
||||
public void testNoParamGiven() throws TemplateModelException {
|
||||
durationMethod.exec(Collections.emptyList());
|
||||
}
|
||||
|
||||
@Test(expected = TemplateModelException.class)
|
||||
public void testNoDurationObject() throws TemplateModelException {
|
||||
durationMethod.exec(Arrays.asList(new StringModel("", getWrapper())));
|
||||
}
|
||||
|
||||
@Test(expected = TemplateModelException.class)
|
||||
public void testNoStringModelObject() throws TemplateModelException {
|
||||
durationMethod.exec(Arrays.asList(""));
|
||||
}
|
||||
|
||||
|
||||
private List<Object> getSecondParameters() {
|
||||
return Arrays.asList(new StringModel(Duration.ofSeconds(SECOND_AMOUNT), getWrapper()));
|
||||
}
|
||||
|
||||
private List<Object> getMinuteParameter() {
|
||||
return Arrays.asList(new StringModel(Duration.ofMinutes(MINUTES_AMOUNT), getWrapper()));
|
||||
}
|
||||
|
||||
private List<Object> getHourParameter() {
|
||||
return Arrays.asList(new StringModel(Duration.ofHours(HOURS_AMOUNT), getWrapper()));
|
||||
}
|
||||
|
||||
private List<Object> getDayParameter() {
|
||||
return Arrays.asList(new StringModel(Duration.ofDays(DAYS_AMOUNT), getWrapper()));
|
||||
}
|
||||
|
||||
private List<Object> getMixedParameter() {
|
||||
return Arrays.asList(new StringModel(Duration.ofSeconds(SECOND_AMOUNT)
|
||||
.plus(Duration.ofMinutes(MINUTES_AMOUNT))
|
||||
.plus(Duration.ofHours(HOURS_AMOUNT))
|
||||
.plus(Duration.ofDays(DAYS_AMOUNT)), getWrapper()));
|
||||
}
|
||||
|
||||
private DefaultObjectWrapper getWrapper() {
|
||||
return new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_0).build();
|
||||
}
|
||||
|
||||
private HashMap<String, Object> getHashMap(long days, long hours, long minutes, long seconds) {
|
||||
HashMap<String, Object> map = new HashMap<>();
|
||||
map.put(DAYS, days);
|
||||
map.put(HOURS, hours);
|
||||
map.put(MINUTES, minutes);
|
||||
map.put(SECONDS, seconds);
|
||||
return map;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user