src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public View getView() { return view; } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testGetView() { assertEquals(view, presenter.getView()); }
|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public void initialise() { templateLoaded = false; openShiftClientService.call(getDefaultSettingsSuccessCallback(), popupHelper.getPopupErrorCallback()).getDefaultSettings(); } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testInitializeSuccessful() { DefaultSettings defaultSettings = mock(DefaultSettings.class); when(defaultSettings.getValue(DefaultSettings.DEFAULT_OPEN_SHIFT_TEMPLATE)).thenReturn(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE); when(defaultSettings.getValue(DefaultSettings.DEFAULT_OPEN_SHIFT_IMAGE_STREAMS)).thenReturn(DEFAULT_OPEN_SHIFT_IMAGE_STREAMS_VALUE); when(defaultSettings.getValue(DefaultSettings.DEFAULT_OPEN_SHIFT_SECRETS)).thenReturn(DEFAULT_OPEN_SHIFT_SECRETS_VALUE); when(openShiftClientService.getDefaultSettings()).thenReturn(defaultSettings); when(openShiftClientService.getTemplateModel(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE)).thenReturn(templateDescriptorModel); presenter.initialise(); verify(view, times(1)).setTemplateURL(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE); verify(view, times(1)).setImageStreamsURL(DEFAULT_OPEN_SHIFT_IMAGE_STREAMS_VALUE); verify(view, times(1)).setSecretsFileURL(DEFAULT_OPEN_SHIFT_SECRETS_VALUE); }
@Test public void testInitializeFailed() { when(openShiftClientService.getTemplateModel(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE)).thenReturn(templateDescriptorModel); prepareServiceCallerError(openShiftClientService, openshiftClientServiceCaller); presenter.initialise(); verify(errorCallback, times(1)).error(any(Message.class), exceptionCaptor.capture()); assertEquals(SERVICE_CALLER_EXCEPTION_MESSAGE, exceptionCaptor.getValue().getMessage()); }
|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public void prepareView() { paramsEditorPresenter.getView().redraw(); } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testPrepareView() { presenter.prepareView(); verify(paramsEditorPresenterView, times(1)).redraw(); }
|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public void isComplete(final Callback<Boolean> callback) { boolean isValid = isRuntimeValid() && isTemplateValid() && isParamsValid() && isImageStreamsURLValid() && isSecretsFileURLValid(); callback.callback(isValid); } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testIsComplete() { when(view.getRuntimeName()).thenReturn(EMPTY_STRING); when(view.getImageStreamsURL()).thenReturn(EMPTY_STRING); when(view.getSecretsFileURL()).thenReturn(EMPTY_STRING); presenter.isComplete(Assert::assertFalse); when(view.getRuntimeName()).thenReturn(RUNTIME_NAME_VALUE); when(openShiftClientService.isValidProjectName(RUNTIME_NAME_VALUE)).thenReturn(true); presenter.onRuntimeNameChange(); presenter.isComplete(Assert::assertFalse); when(view.getImageStreamsURL()).thenReturn(DEFAULT_OPEN_SHIFT_IMAGE_STREAMS_VALUE); presenter.isComplete(Assert::assertFalse); when(view.getSecretsFileURL()).thenReturn(DEFAULT_OPEN_SHIFT_SECRETS_VALUE); presenter.isComplete(Assert::assertFalse); when(view.getTemplateURL()).thenReturn(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE); when(openShiftClientService.getTemplateModel(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE)).thenReturn(templateDescriptorModel); presenter.onTemplateURLChange(); presenter.isComplete(Assert::assertFalse); requiredTemplateParams.forEach(param -> param.setValue("some value")); presenter.isComplete(Assert::assertTrue); }
|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public void clear() { runtimeNameValid = false; clearParams(); view.clear(); } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testClear() { presenter.clear(); verify(paramsEditorPresenter, times(1)).clear(); verify(view, times(1)).clearRequiredParamsHelpText(); }
|
AutocompleteTextAreaDOMElementFactory extends BaseSingletonDOMElementFactory<String, MonacoEditorWidget, MonacoEditorDOMElement> { @Override protected MonacoEditorDOMElement createDomElementInternal(final MonacoEditorWidget widget, final GridLayer gridLayer, final GridWidget gridWidget) { final MonacoEditorDOMElement domElement = makeMonacoEditorDOMElement(widget, gridLayer, gridWidget); domElement.setupElements(); return domElement; } AutocompleteTextAreaDOMElementFactory(final DMNGridPanel gridPanel,
final GridLayer gridLayer,
final GridWidget gridWidget,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Function<GridCellTuple, Command> hasNoValueCommand,
final Function<GridCellValueTuple, Command> hasValueCommand); Function<GridCellTuple, Command> getHasNoValueCommand(); Function<GridCellValueTuple, Command> getHasValueCommand(); @Override MonacoEditorWidget createWidget(); }
|
@Test public void testCreateDomElementInternal() { final MonacoEditorWidget widget = mock(MonacoEditorWidget.class); final MonacoEditorDOMElement domElement = getFactoryForAttachDomElementTest().createDomElementInternal(widget, gridLayer, gridWidget); verify(domElement).setupElements(); }
|
TemplateParamsFormPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public Map<String, String> buildParams() { final Map<String, String> pipelineParams = new HashMap<>(); String runtimeName = getRuntimeName(); String projectName = runtimeName; String applicationName = runtimeName; String serviceName = runtimeName + SERVICE_NAME_SUFFIX; String imageStreamNamespace = projectName; pipelineParams.put(NewDeployWizard.RUNTIME_NAME, runtimeName); pipelineParams.put(PROJECT_NAME, projectName); pipelineParams.put(APPLICATION_NAME, applicationName); pipelineParams.put(SERVICE_NAME, serviceName); pipelineParams.put(RESOURCE_TEMPLATE_URI, getTemplateURL()); pipelineParams.put(RESOURCE_STREAMS_URI, getImageStreamsURL()); pipelineParams.put(RESOURCE_SECRETS_URI, getSecretsFileURL()); if (configuredContainers != null && !configuredContainers.isEmpty()) { pipelineParams.put(KIE_SERVER_CONTAINER_DEPLOYMENT, buildContainerDeploymentParamValue(configuredContainers)); } StringBuilder builder = new StringBuilder(); params.forEach(param -> { if (!isBanned(param.getName()) && !isEmpty(param.getValue())) { addTemplateParam(builder, param.getName(), param.getValue()); } }); addTemplateParam(builder, IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM, imageStreamNamespace); addTemplateParam(builder, APPLICATION_NAME_TEMPLATE_PARAM, applicationName); pipelineParams.put(RESOURCE_TEMPLATE_PARAM_VALUES, builder.toString()); return pipelineParams; } @Inject TemplateParamsFormPresenter(final View view,
final TemplateParamsTablePresenter paramsEditorPresenter,
final TranslationService translationService,
final PopupHelper popupHelper,
final Caller<OpenShiftClientService> openShiftClientService,
final OpenShiftClientValidationService openShiftClientValidationService); @PostConstruct void init(); @Override String getWizardTitle(); @Override View getView(); @Override Map<String, String> buildParams(); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override void clear(); static final String PARAM_DELIMITER; static final String PARAM_ASSIGNER; static final String CONTAINER_DELIMITER; static final String RESOURCE_TEMPLATE_PARAM_VALUES; static final String RESOURCE_TEMPLATE_URI; static final String RESOURCE_SECRETS_URI; static final String RESOURCE_STREAMS_URI; static final String APPLICATION_NAME; static final String PROJECT_NAME; static final String SERVICE_NAME; static final String KIE_SERVER_CONTAINER_DEPLOYMENT; static final String IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM; static final String APPLICATION_NAME_TEMPLATE_PARAM; static final String SERVICE_NAME_SUFFIX; static final String HORNETQ_QUEUES; static final String HORNETQ_TOPICS; static final String HORNETQ_CLUSTER_PASSWORD; }
|
@Test public void testBuildParams() { when(view.getRuntimeName()).thenReturn(RUNTIME_NAME_VALUE); when(view.getImageStreamsURL()).thenReturn(DEFAULT_OPEN_SHIFT_IMAGE_STREAMS_VALUE); when(view.getSecretsFileURL()).thenReturn(DEFAULT_OPEN_SHIFT_SECRETS_VALUE); when(openShiftClientService.isValidProjectName(RUNTIME_NAME_VALUE)).thenReturn(true); presenter.onRuntimeNameChange(); when(view.getTemplateURL()).thenReturn(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE); when(openShiftClientService.getTemplateModel(DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE)).thenReturn(templateDescriptorModel); presenter.onTemplateURLChange(); List<ContainerConfig> containerConfigs = mockContainerConfigList(CONTAINER_CONFIG_COUNT); presenter.onContainerConfigurationsChange(new ContainerConfigParamsChangeEvent(containerConfigs)); for (int i = 0; i < allTemplateParams.size(); i++) { String paramValue = "PARAM_VALUE" + String.valueOf(i); allTemplateParams.get(i).setValue(paramValue); } StringBuilder templateParamsValueBuilder = new StringBuilder(); managedTemplateParams.forEach(param -> { if (templateParamsValueBuilder.length() > 0) { templateParamsValueBuilder.append(","); } templateParamsValueBuilder.append(param.getName()); templateParamsValueBuilder.append("="); templateParamsValueBuilder.append(param.getValue()); }); templateParamsValueBuilder.append("," + IMAGE_STREAM_NAMESPACE_TEMPLATE_PARAM + "=" + RUNTIME_NAME_VALUE); templateParamsValueBuilder.append("," + APPLICATION_NAME_TEMPLATE_PARAM + "=" + RUNTIME_NAME_VALUE); Map<String, String> expectedParams = new HashMap<>(); expectedParams.put(NewDeployWizard.RUNTIME_NAME, RUNTIME_NAME_VALUE); expectedParams.put(PROJECT_NAME, RUNTIME_NAME_VALUE); expectedParams.put(APPLICATION_NAME, RUNTIME_NAME_VALUE); expectedParams.put(SERVICE_NAME, RUNTIME_NAME_VALUE + SERVICE_NAME_SUFFIX); expectedParams.put(RESOURCE_TEMPLATE_URI, DEFAULT_OPEN_SHIFT_TEMPLATE_VALUE); expectedParams.put(RESOURCE_STREAMS_URI, DEFAULT_OPEN_SHIFT_IMAGE_STREAMS_VALUE); expectedParams.put(RESOURCE_SECRETS_URI, DEFAULT_OPEN_SHIFT_SECRETS_VALUE); expectedParams.put(KIE_SERVER_CONTAINER_DEPLOYMENT, buildExpectedContainerDeploymentParamValue(containerConfigs)); expectedParams.put(RESOURCE_TEMPLATE_PARAM_VALUES, templateParamsValueBuilder.toString()); Map<String, String> result = presenter.buildParams(); assertEquals(expectedParams, result); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public ProviderConfiguration buildProviderConfiguration() { final Map<String, Object> values = new HashMap<>(); values.put(MASTER_URL, getMasterURL()); values.put(USER, getUsername()); values.put(PASSWORD, getPassword()); return new ProviderConfiguration(getProviderName(), values); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testBuildProviderConfiguration() { when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); when(view.getMasterURL()).thenReturn(MASTER_URL_VALUE); when(view.getUsername()).thenReturn(USER_VALUE); when(view.getPassword()).thenReturn(PASSWORD_VALUE); ProviderConfiguration configuration = presenter.buildProviderConfiguration(); assertEquals(PROVIDER_NAME_VALUE, presenter.getProviderName()); assertEquals(MASTER_URL_VALUE, configuration.getValues().get(MASTER_URL)); assertEquals(USER_VALUE, configuration.getValues().get(USER)); assertEquals(PASSWORD_VALUE, configuration.getValues().get(PASSWORD)); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void clear() { view.clear(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testClear() { presenter.clear(); verify(view, times(1)).clear(); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void load(final Provider provider) { clear(); view.setProviderName(provider.getKey().getId()); view.setMasterURL(getStringValue(provider.getConfiguration().getValues(), MASTER_URL)); view.setUsername(getStringValue(provider.getConfiguration().getValues(), USER)); view.setPassword(getStringValue(provider.getConfiguration().getValues(), PASSWORD)); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testLoad() { Map<String, Object> values = new HashMap<>(); values.put(MASTER_URL, MASTER_URL_VALUE); values.put(USER, USER_VALUE); values.put(PASSWORD, PASSWORD_VALUE); Provider provider = mock(Provider.class); ProviderKey providerKey = mock(ProviderKey.class); ProviderConfiguration configuration = mock(ProviderConfiguration.class); when(provider.getKey()).thenReturn(providerKey); when(providerKey.getId()).thenReturn(PROVIDER_NAME_VALUE); when(provider.getConfiguration()).thenReturn(configuration); when(configuration.getValues()).thenReturn(values); presenter.load(provider); verify(view, times(1)).clear(); verify(view, times(1)).setProviderName(PROVIDER_NAME_VALUE); verify(view, times(1)).setMasterURL(MASTER_URL_VALUE); verify(view, times(1)).setUsername(USER_VALUE); verify(view, times(1)).setPassword(PASSWORD_VALUE); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getProviderName() { return view.getProviderName(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetProviderName() { when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); assertEquals(PROVIDER_NAME_VALUE, presenter.getProviderName()); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getMasterURL() { return view.getMasterURL(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetMasterURL() { when(view.getMasterURL()).thenReturn(MASTER_URL_VALUE); assertEquals(MASTER_URL_VALUE, presenter.getMasterURL()); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getUsername() { return view.getUsername(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetUser() { when(view.getUsername()).thenReturn(USER_VALUE); assertEquals(USER_VALUE, presenter.getUsername()); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getPassword() { return view.getPassword(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetPassword() { when(view.getPassword()).thenReturn(PASSWORD_VALUE); assertEquals(PASSWORD_VALUE, presenter.getPassword()); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public void isValid(final Callback<Boolean> callback) { boolean isValid = !isEmpty(view.getProviderName()) && !isEmpty(view.getMasterURL()) && !isEmpty(view.getUsername()) && !isEmpty(view.getPassword()); callback.callback(isValid); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testIsValid() { when(view.getProviderName()).thenReturn(EMPTY_STRING); when(view.getMasterURL()).thenReturn(EMPTY_STRING); when(view.getUsername()).thenReturn(EMPTY_STRING); when(view.getPassword()).thenReturn(EMPTY_STRING); presenter.isValid(Assert::assertFalse); when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); presenter.isValid(Assert::assertFalse); when(view.getMasterURL()).thenReturn(MASTER_URL_VALUE); presenter.isValid(Assert::assertFalse); when(view.getUsername()).thenReturn(USER_VALUE); presenter.isValid(Assert::assertFalse); when(view.getPassword()).thenReturn(PASSWORD_VALUE); presenter.isValid(Assert::assertTrue); }
|
OpenShiftProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void disable() { view.disable(); } @Inject OpenShiftProviderConfigPresenter(final View view); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getMasterURL(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testDisable() { presenter.disable(); verify(view, times(1)).disable(); }
|
TextAreaSingletonDOMElementFactory extends BaseSingletonDOMElementFactory<String, TextArea, TextAreaDOMElement> { @Override protected KeyDownHandlerCommon destroyOrFlushKeyDownHandler() { return new KeyDownHandlerCommon(gridPanel, gridLayer, gridWidget, this, true, false, true); } TextAreaSingletonDOMElementFactory(final DMNGridPanel gridPanel,
final GridLayer gridLayer,
final GridWidget gridWidget,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Function<GridCellTuple, Command> hasNoValueCommand,
final Function<GridCellValueTuple, Command> hasValueCommand); Function<GridCellTuple, Command> getHasNoValueCommand(); Function<GridCellValueTuple, Command> getHasValueCommand(); @Override TextArea createWidget(); }
|
@Test public void testKeyDownHandlerCommon_KEY_TAB() { final TextAreaSingletonDOMElementFactory factory = spy(getFactoryForAttachDomElementTest()); final KeyDownHandlerCommon keyDownHandlerCommon = factory.destroyOrFlushKeyDownHandler(); when(event.getNativeKeyCode()).thenReturn(KeyCodes.KEY_TAB); keyDownHandlerCommon.onKeyDown(event); verify(factory).flush(); }
@Test public void testKeyDownHandlerCommon_KEY_ENTER() { final TextAreaSingletonDOMElementFactory factory = spy(getFactoryForAttachDomElementTest()); final KeyDownHandlerCommon keyDownHandlerCommon = factory.destroyOrFlushKeyDownHandler(); when(event.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ENTER); keyDownHandlerCommon.onKeyDown(event); verify(factory, never()).flush(); }
@Test public void testKeyDownHandlerCommon_KEY_ESCAPE() { final TextAreaSingletonDOMElementFactory factory = spy(getFactoryForAttachDomElementTest()); final KeyDownHandlerCommon keyDownHandlerCommon = factory.destroyOrFlushKeyDownHandler(); when(event.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ESCAPE); keyDownHandlerCommon.onKeyDown(event); verify(factory, never()).flush(); }
|
WildflyClientServiceImpl implements WildflyClientService { @Override public TestConnectionResult testConnection(final String host, final int port, final int managementPort, final String user, final String password) { final TestConnectionResult result = new TestConnectionResult(); try { final String testMessage = createWFClient(host, port, managementPort, user, password).testConnection(); result.setManagementConnectionError(false); result.setManagementConnectionMessage(testMessage); } catch (Exception e) { result.setManagementConnectionError(true); result.setManagementConnectionMessage(e.getMessage()); } return result; } @Override TestConnectionResult testConnection(final String host,
final int port,
final int managementPort,
final String user,
final String password); }
|
@Test public void testTestConnectionSuccessful() { when(wfClient.testConnection()).thenReturn(CONNECTION_SUCCESSFUL); TestConnectionResult result = wildflyClientService.testConnection(DUMMY_VALUE, DUMMY_INT_VALUE, DUMMY_INT_VALUE, DUMMY_VALUE, DUMMY_VALUE); assertFalse(result.getManagementConnectionError()); assertEquals(CONNECTION_SUCCESSFUL, result.getManagementConnectionMessage()); }
@Test public void testTestConnectionFailed() { when(wfClient.testConnection()).thenThrow(new WildflyClientException(ERROR_MESSAGE)); TestConnectionResult result = wildflyClientService.testConnection(DUMMY_VALUE, DUMMY_INT_VALUE, DUMMY_INT_VALUE, DUMMY_VALUE, DUMMY_VALUE); assertTrue(result.getManagementConnectionError()); assertEquals(ERROR_MESSAGE, result.getManagementConnectionMessage()); }
|
WildflyProviderConfigConverter implements ProviderConfigConverter<ProviderConfiguration, WildflyProviderConfig> { @Override public WildflyProviderConfig toDomain(ProviderConfiguration modelValue) { if (modelValue == null) { return null; } return new WildflyProviderConfigImpl(modelValue.getId(), getStringValue(modelValue.getValues(), HOST), getStringValue(modelValue.getValues(), PORT), getStringValue(modelValue.getValues(), MANAGEMENT_PORT), getStringValue(modelValue.getValues(), WILDFLY_USER), getStringValue(modelValue.getValues(), WILDFLY_PASSWORD)); } WildflyProviderConfigConverter(); @Override Class<ProviderConfiguration> getModelType(); @Override Class<WildflyProviderConfig> getDomainType(); @Override WildflyProviderConfig toDomain(ProviderConfiguration modelValue); @Override ProviderConfiguration toModel(WildflyProviderConfig domainValue); }
|
@Test public void testToDomain() { Map<String, Object> values = new HashMap<>(); values.put(HOST, HOST_VALUE); values.put(PORT, PORT_VALUE); values.put(MANAGEMENT_PORT, MANAGEMENT_PORT_VALUE); values.put(WILDFLY_USER, WILDFLY_USER_VALUE); values.put(WILDFLY_PASSWORD, WILDFLY_PASSWORD_VALUE); ProviderConfiguration configuration = new ProviderConfiguration(PROVIDER_NAME_VALUE, values); WildflyProviderConfig result = converter.toDomain(configuration); assertNotNull(result); assertEquals(PROVIDER_NAME_VALUE, result.getName()); assertEquals(HOST_VALUE, result.getHost()); assertEquals(PORT_VALUE, result.getPort()); assertEquals(MANAGEMENT_PORT_VALUE, result.getManagementPort()); assertEquals(WILDFLY_USER_VALUE, result.getUser()); assertEquals(WILDFLY_PASSWORD_VALUE, result.getPassword()); }
@Test public void testToDomainNull() { assertNull(converter.toDomain(null)); }
|
WildflyProviderConfigConverter implements ProviderConfigConverter<ProviderConfiguration, WildflyProviderConfig> { @Override public ProviderConfiguration toModel(WildflyProviderConfig domainValue) { if (domainValue == null) { return null; } final Map<String, Object> values = new HashMap<>(); values.put(PROVIDER_NAME, domainValue.getName()); values.put(HOST, domainValue.getHost()); values.put(PORT, domainValue.getPort()); values.put(MANAGEMENT_PORT, domainValue.getManagementPort()); values.put(WILDFLY_USER, domainValue.getUser()); values.put(WILDFLY_PASSWORD, domainValue.getPassword()); return new ProviderConfiguration(domainValue.getName(), values); } WildflyProviderConfigConverter(); @Override Class<ProviderConfiguration> getModelType(); @Override Class<WildflyProviderConfig> getDomainType(); @Override WildflyProviderConfig toDomain(ProviderConfiguration modelValue); @Override ProviderConfiguration toModel(WildflyProviderConfig domainValue); }
|
@Test public void testToModel() { WildflyProviderConfig config = mock(WildflyProviderConfig.class); when(config.getName()).thenReturn(PROVIDER_NAME_VALUE); when(config.getHost()).thenReturn(HOST_VALUE); when(config.getPort()).thenReturn(PORT_VALUE); when(config.getManagementPort()).thenReturn(MANAGEMENT_PORT_VALUE); when(config.getUser()).thenReturn(WILDFLY_USER_VALUE); when(config.getPassword()).thenReturn(WILDFLY_PASSWORD_VALUE); ProviderConfiguration result = converter.toModel(config); assertNotNull(result); assertEquals(PROVIDER_NAME_VALUE, result.getId()); assertEquals(HOST_VALUE, result.getValues().get(HOST)); assertEquals(PORT_VALUE, result.getValues().get(PORT)); assertEquals(MANAGEMENT_PORT_VALUE, result.getValues().get(MANAGEMENT_PORT)); assertEquals(WILDFLY_USER_VALUE, result.getValues().get(WILDFLY_USER)); assertEquals(WILDFLY_PASSWORD_VALUE, result.getValues().get(WILDFLY_PASSWORD)); }
@Test public void testToModelNull() { assertNull(converter.toModel(null)); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public ProviderConfiguration buildProviderConfiguration() { final Map<String, Object> values = new HashMap<>(); values.put(HOST, getHost()); values.put(PORT, getPort()); values.put(MANAGEMENT_PORT, getManagementPort()); values.put(USER, getUsername()); values.put(PASSWORD, getPassword()); return new ProviderConfiguration(getProviderName(), values); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testBuildProviderConfiguration() { when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); when(view.getHost()).thenReturn(HOST_VALUE); when(view.getPort()).thenReturn(PORT_VALUE); when(view.getManagementPort()).thenReturn(MANAGEMENT_PORT_VALUE); when(view.getUsername()).thenReturn(USER_VALUE); when(view.getPassword()).thenReturn(PASSWORD_VALUE); ProviderConfiguration configuration = presenter.buildProviderConfiguration(); assertEquals(PROVIDER_NAME_VALUE, presenter.getProviderName()); assertEquals(HOST_VALUE, configuration.getValues().get(HOST)); assertEquals(PORT_VALUE, configuration.getValues().get(PORT)); assertEquals(MANAGEMENT_PORT_VALUE, configuration.getValues().get(MANAGEMENT_PORT)); assertEquals(USER_VALUE, configuration.getValues().get(USER)); assertEquals(PASSWORD_VALUE, configuration.getValues().get(PASSWORD)); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void clear() { view.clear(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testClear() { presenter.clear(); verify(view, times(1)).clear(); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void load(final Provider provider) { clear(); view.setProviderName(provider.getKey().getId()); view.setHost(getStringValue(provider.getConfiguration().getValues(), HOST)); view.setPort(getStringValue(provider.getConfiguration().getValues(), PORT)); view.setManagementPort(getStringValue(provider.getConfiguration().getValues(), MANAGEMENT_PORT)); view.setUsername(getStringValue(provider.getConfiguration().getValues(), USER)); view.setPassword(PASSWORD_MASK); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testLoad() { Map<String, Object> values = new HashMap<>(); values.put(HOST, HOST_VALUE); values.put(PORT, PORT_VALUE); values.put(MANAGEMENT_PORT, MANAGEMENT_PORT_VALUE); values.put(USER, USER_VALUE); values.put(PASSWORD, PASSWORD_VALUE); Provider provider = mock(Provider.class); ProviderKey providerKey = mock(ProviderKey.class); ProviderConfiguration configuration = mock(ProviderConfiguration.class); when(provider.getKey()).thenReturn(providerKey); when(providerKey.getId()).thenReturn(PROVIDER_NAME_VALUE); when(provider.getConfiguration()).thenReturn(configuration); when(configuration.getValues()).thenReturn(values); presenter.load(provider); verify(view, times(1)).setProviderName(PROVIDER_NAME_VALUE); verify(view, times(1)).setHost(HOST_VALUE); verify(view, times(1)).setPort(PORT_VALUE); verify(view, times(1)).setManagementPort(MANAGEMENT_PORT_VALUE); verify(view, times(1)).setUsername(USER_VALUE); verify(view, times(1)).setPassword(PASSWORD_MASK); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getProviderName() { return view.getProviderName(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetProviderName() { when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); assertEquals(PROVIDER_NAME_VALUE, presenter.getProviderName()); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Map<Import, Definitions> getImportDefinitions(final Metadata metadata, final List<Import> imports) { final Map<Import, Definitions> importDefinitions = new HashMap<>(); if (imports.size() > 0) { for (final Definitions definitions : getOtherDMNDiagramsDefinitions(metadata)) { findImportByDefinitions(definitions, imports).ifPresent(anImport -> { importDefinitions.put(anImport, definitions); }); } } return importDefinitions; } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }
|
@Test public void testGetImportDefinitions() { final Metadata metadata = mock(Metadata.class); final Import import1 = mock(Import.class); final Import import2 = mock(Import.class); final Import import3 = mock(Import.class); final List<Import> imports = asList(import1, import2, import3); final Definitions definitions1 = mock(Definitions.class); final Definitions definitions2 = mock(Definitions.class); final Definitions definitions3 = mock(Definitions.class); final List<Definitions> definitions = asList(definitions1, definitions2, definitions3); when(definitions1.getNamespace()).thenReturn(": when(definitions2.getNamespace()).thenReturn(": when(definitions3.getNamespace()).thenReturn(": when(import1.getNamespace()).thenReturn(": when(import2.getNamespace()).thenReturn(": when(import3.getNamespace()).thenReturn(": doReturn(definitions).when(helper).getOtherDMNDiagramsDefinitions(metadata); final Map<Import, Definitions> importDefinitions = helper.getImportDefinitions(metadata, imports); assertEquals(2, importDefinitions.size()); assertEquals(definitions1, importDefinitions.get(import1)); assertEquals(definitions3, importDefinitions.get(import3)); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getHost() { return view.getHost(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetHost() { when(view.getHost()).thenReturn(HOST_VALUE); assertEquals(HOST_VALUE, presenter.getHost()); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getPort() { return view.getPort(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetPort() { when(view.getPort()).thenReturn(PORT_VALUE); assertEquals(PORT_VALUE, presenter.getPort()); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getManagementPort() { return view.getManagementPort(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetManagementPort() { when(view.getManagementPort()).thenReturn(MANAGEMENT_PORT_VALUE); assertEquals(MANAGEMENT_PORT_VALUE, presenter.getManagementPort()); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getUsername() { return view.getUsername(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetUser() { when(view.getUsername()).thenReturn(USER_VALUE); assertEquals(USER_VALUE, presenter.getUsername()); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public String getPassword() { return view.getPassword(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testGetPassword() { when(view.getPassword()).thenReturn(PASSWORD_VALUE); assertEquals(PASSWORD_VALUE, presenter.getPassword()); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { public void isValid(final Callback<Boolean> callback) { boolean isValid = !isEmpty(view.getProviderName()) && !isEmpty(view.getHost()) && isValidPort(view.getPort()) && isValidPort(view.getManagementPort()) && !isEmpty(view.getUsername()) && !isEmpty(view.getPassword()); callback.callback(isValid); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testIsValid() { when(view.getProviderName()).thenReturn(EMPTY_VALUE); when(view.getHost()).thenReturn(EMPTY_VALUE); when(view.getPort()).thenReturn(EMPTY_VALUE); when(view.getManagementPort()).thenReturn(EMPTY_VALUE); when(view.getUsername()).thenReturn(EMPTY_VALUE); when(view.getPassword()).thenReturn(EMPTY_VALUE); presenter.isValid(Assert::assertFalse); when(view.getProviderName()).thenReturn(PROVIDER_NAME_VALUE); presenter.isValid(Assert::assertFalse); when(view.getHost()).thenReturn(HOST_VALUE); presenter.isValid(Assert::assertFalse); when(view.getPort()).thenReturn(PORT_VALUE); presenter.isValid(Assert::assertFalse); when(view.getManagementPort()).thenReturn(MANAGEMENT_PORT_VALUE); presenter.isValid(Assert::assertFalse); when(view.getUsername()).thenReturn(USER_VALUE); presenter.isValid(Assert::assertFalse); when(view.getPassword()).thenReturn(PASSWORD_VALUE); presenter.isValid(Assert::assertTrue); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { @Override public void disable() { view.disable(); } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testDisable() { presenter.disable(); verify(view, times(1)).disable(); }
|
WF10ProviderConfigPresenter extends AbstractHasContentChangeHandlers implements ProviderConfigurationForm { protected void onTestConnection() { if (validateRemoteParams()) { wildflyClientService.call(getTestConnectionSuccessCallback(), getTestConnectionErrorCallback()).testConnection(view.getHost(), getInt(view.getPort()), getInt(view.getManagementPort()), view.getUsername(), view.getPassword()); } } @Inject WF10ProviderConfigPresenter(final View view,
final Caller<WildflyClientService> wildflyClientService); @PostConstruct void init(); View getView(); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); @Override void load(final Provider provider); String getProviderName(); String getHost(); String getPort(); String getManagementPort(); String getUsername(); String getPassword(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); }
|
@Test public void testOnTestConnectionWithMissingParams() { when(view.getParamsNotCompletedErrorMessage()).thenReturn(ERROR_MESSAGE); presenter.onTestConnection(); verify(view, times(1)).showInformationPopup(ERROR_MESSAGE); }
@Test public void testOnTestConnectionWhenConnectionFailed() { when(view.getTestConnectionFailMessage(ERROR_MESSAGE)).thenReturn(ERROR_MESSAGE_TRANSFORMED); TestConnectionResult result = mock(TestConnectionResult.class); when(result.getManagementConnectionError()).thenReturn(true); when(result.getManagementConnectionMessage()).thenReturn(ERROR_MESSAGE); when(wildflyClientService.testConnection(HOST_VALUE, Integer.parseInt(PORT_VALUE), Integer.parseInt(MANAGEMENT_PORT_VALUE), USER_VALUE, PASSWORD_VALUE)).thenReturn(result); fillConnectionParams(); presenter.onTestConnection(); verify(view, times(1)).showInformationPopup(ERROR_MESSAGE_TRANSFORMED); }
@Test public void testOnTestConnectionWhenConnectionSuccessful() { when(view.getTestConnectionSuccessfulMessage(SUCCESS_MESSAGE)).thenReturn(SUCCESS_MESSAGE_TRANSFORMED); TestConnectionResult result = mock(TestConnectionResult.class); when(result.getManagementConnectionError()).thenReturn(false); when(result.getManagementConnectionMessage()).thenReturn(SUCCESS_MESSAGE); when(wildflyClientService.testConnection(HOST_VALUE, Integer.parseInt(PORT_VALUE), Integer.parseInt(MANAGEMENT_PORT_VALUE), USER_VALUE, PASSWORD_VALUE)).thenReturn(result); fillConnectionParams(); presenter.onTestConnection(); verify(view, times(1)).showInformationPopup(SUCCESS_MESSAGE_TRANSFORMED); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public List<ProviderType> getProviderTypes(Integer page, Integer pageSize, String sort, boolean sortOrder) throws BusinessException { return runtimeProvisioningService.getProviderTypes(page, pageSize, sort, sortOrder).getItems(); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testGetProviderTypes() { List<ProviderType> values = mockList(ProviderType.class, ELEMENTS_COUNT); ProviderTypeList list = new ProviderTypeList(values); when(runtimeProvisioningService.getProviderTypes(PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(list); List<ProviderType> result = runtimeProvisioningServiceBackend.getProviderTypes(PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(runtimeProvisioningService, times(1)).getProviderTypes(PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(values, result); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public List<Provider> getProviders(Integer page, Integer pageSize, String sort, boolean sortOrder) throws BusinessException { return runtimeProvisioningService.getProviders(page, pageSize, sort, sortOrder).getItems(); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testGetProviders() { List<Provider> values = mockList(Provider.class, ELEMENTS_COUNT); ProviderList list = new ProviderList(values); when(runtimeProvisioningService.getProviders(PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(list); List<Provider> result = runtimeProvisioningServiceBackend.getProviders(PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(runtimeProvisioningService, times(1)).getProviders(PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(values, result); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public List<Runtime> getRuntimes(Integer page, Integer pageSize, String sort, boolean sortOrder) throws BusinessException { return runtimeProvisioningService.getRuntimes(page, pageSize, sort, sortOrder).getItems(); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testGetRuntimes() { List<Runtime> values = mockList(Runtime.class, ELEMENTS_COUNT); RuntimeList list = new RuntimeList(values); when(runtimeProvisioningService.getRuntimes(PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(list); List<Runtime> result = runtimeProvisioningServiceBackend.getRuntimes(PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(runtimeProvisioningService, times(1)).getRuntimes(PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(values, result); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void registerProvider(ProviderConfig conf) throws BusinessException { runtimeProvisioningService.registerProvider(conf); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testRegisterProvider() { ProviderConfig providerConfig = mock(ProviderConfig.class); runtimeProvisioningServiceBackend.registerProvider(providerConfig); verify(runtimeProvisioningService, times(1)).registerProvider(providerConfig); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void unregisterProvider(String name) throws BusinessException { runtimeProvisioningService.deregisterProvider(name); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void unregisterProvider() { runtimeProvisioningServiceBackend.unregisterProvider(PROVIDER_NAME); verify(runtimeProvisioningService, times(1)).deregisterProvider(PROVIDER_NAME); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public String newRuntime(RuntimeConfig conf) throws BusinessException { return runtimeProvisioningService.newRuntime(conf); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testNewRuntime() { RuntimeConfig runtimeConfig = mock(RuntimeConfig.class); when(runtimeProvisioningService.newRuntime(runtimeConfig)).thenReturn(RUNTIME_ID); String result = runtimeProvisioningServiceBackend.newRuntime(runtimeConfig); verify(runtimeProvisioningService, times(1)).newRuntime(runtimeConfig); assertEquals(RUNTIME_ID, result); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void destroyRuntime(String runtimeId, boolean forced) throws BusinessException { runtimeProvisioningService.destroyRuntime(runtimeId, forced); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testDestroyRuntimeNotForced() { runtimeProvisioningServiceBackend.destroyRuntime(RUNTIME_ID, false); verify(runtimeProvisioningService, times(1)).destroyRuntime(RUNTIME_ID, false); }
@Test public void testDestroyRuntimeForced() { runtimeProvisioningServiceBackend.destroyRuntime(RUNTIME_ID, true); verify(runtimeProvisioningService, times(1)).destroyRuntime(RUNTIME_ID, true); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void startRuntime(String runtimeId) throws BusinessException { runtimeProvisioningService.startRuntime(runtimeId); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testStartRuntime() { runtimeProvisioningServiceBackend.startRuntime(RUNTIME_ID); verify(runtimeProvisioningService).startRuntime(RUNTIME_ID); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void stopRuntime(String runtimeId) throws BusinessException { runtimeProvisioningService.stopRuntime(runtimeId); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testStopRuntime() { runtimeProvisioningServiceBackend.stopRuntime(RUNTIME_ID); verify(runtimeProvisioningService).stopRuntime(RUNTIME_ID); }
|
NameAndDataTypeDOMElementColumnRenderer extends BaseGridColumnSingletonDOMElementRenderer<String, W, E> { @Override public Group renderCell(final GridCell<String> cell, final GridBodyCellRenderContext context) { if (cell == null || cell.getValue() == null) { return null; } return RendererUtils.getExpressionCellText(context, cell); } NameAndDataTypeDOMElementColumnRenderer(final BaseSingletonDOMElementFactory<String, W, E> factory); @Override Group renderHeaderContent(final List<GridColumn.HeaderMetaData> headerMetaData,
final GridHeaderColumnRenderContext context,
final int headerRowIndex,
final double blockWidth,
final double rowHeight); @Override Group renderCell(final GridCell<String> cell,
final GridBodyCellRenderContext context); }
|
@Test @SuppressWarnings("unchecked") public void testRenderCellWithValue() { this.cell = new BaseGridCell<>(new BaseGridCellValue<>(TITLE)); assertThat(renderer.renderCell(cell, bodyContext)).isNotNull(); verify(text1).setText(eq(TITLE)); verify(text1).setX(5); verify(text1).setY(5); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public void restartRuntime(String runtimeId) throws BusinessException { runtimeProvisioningService.restartRuntime(runtimeId); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testRestartRuntime() { runtimeProvisioningServiceBackend.restartRuntime(RUNTIME_ID); verify(runtimeProvisioningService).restartRuntime(RUNTIME_ID); }
|
RuntimeProvisioningServiceBackendImpl implements RuntimeProvisioningServiceBackend { @Override public List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query) throws BusinessException { return runtimeProvisioningService.executeQuery(query).getItems(); } RuntimeProvisioningServiceBackendImpl(); @Inject RuntimeProvisioningServiceBackendImpl(final RuntimeProvisioningService runtimeProvisioningService); @Override List<ProviderType> getProviderTypes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Provider> getProviders(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<Runtime> getRuntimes(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override void registerProvider(ProviderConfig conf); @Override void unregisterProvider(String name); @Override String newRuntime(RuntimeConfig conf); @Override void destroyRuntime(String runtimeId,
boolean forced); @Override void startRuntime(String runtimeId); @Override void stopRuntime(String runtimeId); @Override void restartRuntime(String runtimeId); @Override List<RuntimeQueryResultItem> executeQuery(RuntimeQuery query); }
|
@Test public void testExecuteQuery() { RuntimeQuery query = mock(RuntimeQuery.class); List<RuntimeQueryResultItem> values = mockList(RuntimeQueryResultItem.class, ELEMENTS_COUNT); RuntimeQueryResultItemList list = new RuntimeQueryResultItemList(values); when(runtimeProvisioningService.executeQuery(query)).thenReturn(list); List<RuntimeQueryResultItem> result = runtimeProvisioningServiceBackend.executeQuery(query); verify(runtimeProvisioningService, times(1)).executeQuery(query); assertEquals(values, result); }
|
PipelineServiceBackendImpl implements PipelineServiceBackend { @Override public List<PipelineConfig> getPipelineConfigs(Integer page, Integer pageSize, String sort, boolean sortOrder) throws BusinessException { return pipelineService.getPipelineConfigs(page, pageSize, sort, sortOrder).getItems(); } PipelineServiceBackendImpl(); @Inject PipelineServiceBackendImpl(final PipelineService pipelineService); @Override List<PipelineConfig> getPipelineConfigs(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<PipelineConfig> getPipelineConfigs(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<String> getPipelineNames(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override String newPipeline(PipelineConfig pipelineConfig,
ProviderType providerType); @Override String newPipeline(PipelineConfig config); @Override String runPipeline(String id,
Input input,
boolean async); @Override void stopPipelineExecution(final String executionId); @Override void deletePipelineExecution(final String executionId); }
|
@Test public void testGetPipelineConfigs() { List<PipelineConfig> values = mockList(PipelineConfig.class, ELEMENTS_COUNT); PipelineConfigsList list = new PipelineConfigsList(values); when(pipelineService.getPipelineConfigs(PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(list); List<PipelineConfig> result = pipelineServiceBackend.getPipelineConfigs(PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(pipelineService, times(1)).getPipelineConfigs(PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(result, values); }
@Test public void testGetPipelineConfigsForProviderType() { List<PipelineConfig> values = mockList(PipelineConfig.class, ELEMENTS_COUNT); PipelineConfigsList list = new PipelineConfigsList(values); when(pipelineService.getPipelineConfigs(PROVIDER_TYPE_NAME, PROVIDER_TYPE_VERSION, PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(list); List<PipelineConfig> result = pipelineServiceBackend.getPipelineConfigs(providerType, PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(pipelineService, times(1)).getPipelineConfigs(PROVIDER_TYPE_NAME, PROVIDER_TYPE_VERSION, PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(result, values); }
|
PipelineServiceBackendImpl implements PipelineServiceBackend { @Override public List<String> getPipelineNames(ProviderType providerType, Integer page, Integer pageSize, String sort, boolean sortOrder) throws BusinessException { return pipelineService.getPipelineNames(providerType.getProviderTypeName(), providerType.getVersion(), page, pageSize, sort, sortOrder); } PipelineServiceBackendImpl(); @Inject PipelineServiceBackendImpl(final PipelineService pipelineService); @Override List<PipelineConfig> getPipelineConfigs(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<PipelineConfig> getPipelineConfigs(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<String> getPipelineNames(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override String newPipeline(PipelineConfig pipelineConfig,
ProviderType providerType); @Override String newPipeline(PipelineConfig config); @Override String runPipeline(String id,
Input input,
boolean async); @Override void stopPipelineExecution(final String executionId); @Override void deletePipelineExecution(final String executionId); }
|
@Test public void testGetPipelineNames() { List<String> values = mock(List.class); when(pipelineService.getPipelineNames(PROVIDER_TYPE_NAME, PROVIDER_TYPE_VERSION, PAGE, PAGE_SIZE, SORT, SORT_ORDER)).thenReturn(values); List<String> result = pipelineServiceBackend.getPipelineNames(providerType, PAGE, PAGE_SIZE, SORT, SORT_ORDER); verify(pipelineService, times(1)).getPipelineNames(PROVIDER_TYPE_NAME, PROVIDER_TYPE_VERSION, PAGE, PAGE_SIZE, SORT, SORT_ORDER); assertEquals(values, result); }
|
PipelineServiceBackendImpl implements PipelineServiceBackend { @Override public String newPipeline(PipelineConfig pipelineConfig, ProviderType providerType) throws BusinessException { return pipelineService.newPipeline(pipelineConfig, providerType); } PipelineServiceBackendImpl(); @Inject PipelineServiceBackendImpl(final PipelineService pipelineService); @Override List<PipelineConfig> getPipelineConfigs(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<PipelineConfig> getPipelineConfigs(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<String> getPipelineNames(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override String newPipeline(PipelineConfig pipelineConfig,
ProviderType providerType); @Override String newPipeline(PipelineConfig config); @Override String runPipeline(String id,
Input input,
boolean async); @Override void stopPipelineExecution(final String executionId); @Override void deletePipelineExecution(final String executionId); }
|
@Test public void testNewPipelineForProvider() { PipelineConfig pipelineConfig = mock(PipelineConfig.class); when(pipelineService.newPipeline(pipelineConfig, providerType)).thenReturn(PIPELINE_NAME); String result = pipelineServiceBackend.newPipeline(pipelineConfig, providerType); verify(pipelineService, times(1)).newPipeline(pipelineConfig, providerType); assertEquals(PIPELINE_NAME, result); }
@Test public void testNewPipeline() { PipelineConfig pipelineConfig = mock(PipelineConfig.class); when(pipelineService.newPipeline(pipelineConfig)).thenReturn(PIPELINE_NAME); String result = pipelineServiceBackend.newPipeline(pipelineConfig); verify(pipelineService, times(1)).newPipeline(pipelineConfig); assertEquals(PIPELINE_NAME, result); }
|
PipelineServiceBackendImpl implements PipelineServiceBackend { @Override public void stopPipelineExecution(final String executionId) throws BusinessException { pipelineService.stopPipelineExecution(executionId); } PipelineServiceBackendImpl(); @Inject PipelineServiceBackendImpl(final PipelineService pipelineService); @Override List<PipelineConfig> getPipelineConfigs(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<PipelineConfig> getPipelineConfigs(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<String> getPipelineNames(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override String newPipeline(PipelineConfig pipelineConfig,
ProviderType providerType); @Override String newPipeline(PipelineConfig config); @Override String runPipeline(String id,
Input input,
boolean async); @Override void stopPipelineExecution(final String executionId); @Override void deletePipelineExecution(final String executionId); }
|
@Test public void testStopPipelineExecution() { pipelineServiceBackend.stopPipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineService, times(1)).stopPipelineExecution(PIPELINE_EXECUTION_ID); }
|
PipelineServiceBackendImpl implements PipelineServiceBackend { @Override public void deletePipelineExecution(final String executionId) throws BusinessException { pipelineService.deletePipelineExecution(executionId); } PipelineServiceBackendImpl(); @Inject PipelineServiceBackendImpl(final PipelineService pipelineService); @Override List<PipelineConfig> getPipelineConfigs(Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<PipelineConfig> getPipelineConfigs(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override List<String> getPipelineNames(ProviderType providerType,
Integer page,
Integer pageSize,
String sort,
boolean sortOrder); @Override String newPipeline(PipelineConfig pipelineConfig,
ProviderType providerType); @Override String newPipeline(PipelineConfig config); @Override String runPipeline(String id,
Input input,
boolean async); @Override void stopPipelineExecution(final String executionId); @Override void deletePipelineExecution(final String executionId); }
|
@Test public void testDeletePipelineExecution() { pipelineServiceBackend.deletePipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineService, times(1)).deletePipelineExecution(PIPELINE_EXECUTION_ID); }
|
ProvisioningScreensServiceImpl implements ProvisioningScreensService { @Override public ProvidersInfo getProvidersInfo(final ProviderTypeKey providerTypeKey) { checkNotNull("providerTypeKey", providerTypeKey); final ProviderType providerType = providerTypeService.getProviderType(providerTypeKey); if (providerType == null) { return null; } final Collection<ProviderKey> providersKey = providerService.getProvidersKey(providerType); return new ProvidersInfo(providerType, providersKey); } ProvisioningScreensServiceImpl(); @Inject ProvisioningScreensServiceImpl(final ProviderTypeService providerTypeService,
final ProviderService providerService,
final RuntimeService runtimeService); @Override ProvidersInfo getProvidersInfo(final ProviderTypeKey providerTypeKey); @Override RuntimesInfo getRuntimesInfo(final ProviderKey providerKey); @Override boolean hasRuntimes(final ProviderKey providerKey); }
|
@Test public void testGetProvidersInfoProviderTypeExisting() { when(providerTypeService.getProviderType(providerTypeKey)).thenReturn(providerType); when(providerService.getProvidersKey(providerType)).thenReturn(providerKeys); ProvidersInfo providersInfo = service.getProvidersInfo(providerTypeKey); assertNotNull(providersInfo); assertEquals(providerType, providersInfo.getProviderType()); assertEquals(providerKeys, providersInfo.getProvidersKey()); verify(providerTypeService, times(1)).getProviderType(providerTypeKey); verify(providerService, times(1)).getProvidersKey(providerType); }
@Test public void testGetProvidersInfoProviderTypeNotExisting() { when(providerTypeService.getProviderType(providerTypeKey)).thenReturn(null); ProvidersInfo providersInfo = service.getProvidersInfo(providerTypeKey); assertNull(providersInfo); verify(providerTypeService, times(1)).getProviderType(providerTypeKey); verify(providerService, never()).getProvidersKey(providerType); }
|
EditablePopupHeaderMetaData implements EditableHeaderMetaData { @Override public void setColumnGroup(final String columnGroup) { throw new UnsupportedOperationException("Group cannot be set."); } EditablePopupHeaderMetaData(final CellEditorControlsView.Presenter cellEditorControls,
final E editor); @Override void setColumnGroup(final String columnGroup); @Override void setTitle(final String title); @Override void edit(final GridBodyCellEditContext context); @Override void destroyResources(); }
|
@Test(expected = UnsupportedOperationException.class) public void testSetColumnGroup() { header.setColumnGroup("group"); }
|
ProvisioningScreensServiceImpl implements ProvisioningScreensService { @Override public RuntimesInfo getRuntimesInfo(final ProviderKey providerKey) { checkNotNull("providerKey", providerKey); final Provider provider = providerService.getProvider(providerKey); if (provider == null) { return null; } final Collection<RuntimeListItem> items = runtimeService.getRuntimeItems(providerKey); return new RuntimesInfo(provider, items); } ProvisioningScreensServiceImpl(); @Inject ProvisioningScreensServiceImpl(final ProviderTypeService providerTypeService,
final ProviderService providerService,
final RuntimeService runtimeService); @Override ProvidersInfo getProvidersInfo(final ProviderTypeKey providerTypeKey); @Override RuntimesInfo getRuntimesInfo(final ProviderKey providerKey); @Override boolean hasRuntimes(final ProviderKey providerKey); }
|
@Test public void testGetRuntimesInfoProviderExisting() { when(providerService.getProvider(providerKey)).thenReturn(provider); when(runtimeService.getRuntimeItems(providerKey)).thenReturn(runtimeListItems); RuntimesInfo info = service.getRuntimesInfo(providerKey); assertNotNull(info); assertEquals(provider, info.getProvider()); assertEquals(runtimeListItems, info.getRuntimeItems()); verify(providerService, times(1)).getProvider(providerKey); verify(runtimeService, times(1)).getRuntimeItems(providerKey); }
@Test public void testGetRuntimesInfoProviderNotExisting() { when(providerService.getProvider(providerKey)).thenReturn(null); RuntimesInfo info = service.getRuntimesInfo(providerKey); assertNull(info); verify(providerService, times(1)).getProvider(providerKey); verify(runtimeService, never()).getRuntimeItems(providerKey); }
|
ProvisioningScreensServiceImpl implements ProvisioningScreensService { @Override public boolean hasRuntimes(final ProviderKey providerKey) { checkNotNull("providerKey", providerKey); return !runtimeService.getRuntimeItems(providerKey).isEmpty(); } ProvisioningScreensServiceImpl(); @Inject ProvisioningScreensServiceImpl(final ProviderTypeService providerTypeService,
final ProviderService providerService,
final RuntimeService runtimeService); @Override ProvidersInfo getProvidersInfo(final ProviderTypeKey providerTypeKey); @Override RuntimesInfo getRuntimesInfo(final ProviderKey providerKey); @Override boolean hasRuntimes(final ProviderKey providerKey); }
|
@Test public void testHasRuntimesTrue() { Collection<RuntimeListItem> runtimes = mock(Collection.class); when(runtimeService.getRuntimeItems(providerKey)).thenReturn(runtimes); when(runtimes.isEmpty()).thenReturn(false); assertTrue(service.hasRuntimes(providerKey)); verify(runtimeService, times(1)).getRuntimeItems(providerKey); }
@Test public void testHasRuntimesFalse() { Collection<RuntimeListItem> runtimes = mock(Collection.class); when(runtimeService.getRuntimeItems(providerKey)).thenReturn(runtimes); when(runtimes.isEmpty()).thenReturn(true); assertFalse(service.hasRuntimes(providerKey)); verify(runtimeService, times(1)).getRuntimeItems(providerKey); }
|
ServiceUtil { public static final String getStringValue(Map map, String key) { return map.get(key) != null ? map.get(key).toString() : null; } static final String getStringValue(Map map,
String key); }
|
@Test public void getGetStringValue() { Map values = new HashMap(); String result = ServiceUtil.getStringValue(values, KEY); assertNull(result); Object obj = mock(Object.class); when(obj.toString()).thenReturn(STRING_VALUE); values.put(KEY, obj); result = ServiceUtil.getStringValue(values, KEY); assertEquals(STRING_VALUE, result); }
|
RuntimeServiceImpl implements RuntimeService { @Override public Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey) { checkNotNull("providerKey", providerKey); final RuntimeQuery query = RuntimeQueryBuilder.newInstance() .withProviderId(providerKey.getId()) .build(); return buildRuntimeQueryResult(runtimeProvisioningService.executeQuery(query)); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testGetRuntimeItems() { ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); ProviderKey providerKey = new ProviderKey(providerTypeKey, PROVIDER_ID); when(runtimeProvisioningService.executeQuery(any(RuntimeQuery.class))).thenReturn(queryItems); Collection<RuntimeListItem> result = service.getRuntimeItems(providerKey); Collection<RuntimeListItem> expectedResult = buildExpectedResult(queryItems); assertEquals(expectedResult, result); }
|
RuntimeServiceImpl implements RuntimeService { @Override public RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey) { checkNotNull("pipelineExecutionTraceKey", pipelineExecutionTraceKey); final RuntimeQuery query = RuntimeQueryBuilder.newInstance() .withPipelineExecutionId(pipelineExecutionTraceKey.getId()) .build(); return buildRuntimeQueryResult(runtimeProvisioningService.executeQuery(query)).stream() .findFirst() .orElse(null); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void getRuntimeItemByPipelineExecutionKeyExisting() { PipelineExecutionTraceKey traceKey = new PipelineExecutionTraceKey(PIPELINE_EXECUTION_ID); List<RuntimeQueryResultItem> singleResult = mockRuntimeQueryResultItemList(1); when(runtimeProvisioningService.executeQuery(any(RuntimeQuery.class))).thenReturn(singleResult); RuntimeListItem expectedItem = buildExpectedResult(singleResult).iterator().next(); RuntimeListItem result = service.getRuntimeItem(traceKey); assertEquals(expectedItem, result); }
@Test public void getRuntimeItemByPipelineExecutionKeyNotExisting() { PipelineExecutionTraceKey traceKey = new PipelineExecutionTraceKey(PIPELINE_EXECUTION_ID); List<RuntimeQueryResultItem> singleResult = new ArrayList<>(); when(runtimeProvisioningService.executeQuery(any(RuntimeQuery.class))).thenReturn(singleResult); RuntimeListItem result = service.getRuntimeItem(traceKey); assertNull(result); }
@Test public void getRuntimeItemByRuntimeKeyExisting() { ProviderKey providerKey = mock(ProviderKey.class); RuntimeKey runtimeKey = new RuntimeKey(providerKey, RUNTIME_ID); List<RuntimeQueryResultItem> singleResult = mockRuntimeQueryResultItemList(1); when(runtimeProvisioningService.executeQuery(any(RuntimeQuery.class))).thenReturn(singleResult); RuntimeListItem expectedItem = buildExpectedResult(singleResult).iterator().next(); RuntimeListItem result = service.getRuntimeItem(runtimeKey); assertEquals(expectedItem, result); }
@Test public void getRuntimeItemByRuntimeKeyNotExisting() { ProviderKey providerKey = mock(ProviderKey.class); RuntimeKey runtimeKey = new RuntimeKey(providerKey, RUNTIME_ID); List<RuntimeQueryResultItem> singleResult = new ArrayList<>(); when(runtimeProvisioningService.executeQuery(any(RuntimeQuery.class))).thenReturn(singleResult); RuntimeListItem result = service.getRuntimeItem(runtimeKey); assertNull(result); }
|
EditablePopupHeaderMetaData implements EditableHeaderMetaData { @Override public void setTitle(final String title) { throw new UnsupportedOperationException("Title is derived and cannot be set on the HeaderMetaData."); } EditablePopupHeaderMetaData(final CellEditorControlsView.Presenter cellEditorControls,
final E editor); @Override void setColumnGroup(final String columnGroup); @Override void setTitle(final String title); @Override void edit(final GridBodyCellEditContext context); @Override void destroyResources(); }
|
@Test(expected = UnsupportedOperationException.class) public void testSetTitle() { header.setTitle("title"); }
|
RuntimeServiceImpl implements RuntimeService { @Override public Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey) { checkNotNull("providerTypeKey", providerTypeKey); return pipelineService.getPipelineNames(new org.guvnor.ala.runtime.providers.ProviderType() { @Override public String getProviderTypeName() { return providerTypeKey.getId(); } @Override public String getVersion() { return providerTypeKey.getVersion(); } }, 0, 1000, "name", true ).stream().map(PipelineKey::new).collect(Collectors.toList()); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testGetPipelines() { ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); when(pipelineService.getPipelineNames(any(org.guvnor.ala.runtime.providers.ProviderType.class), anyInt(), anyInt(), anyString(), anyBoolean())).thenReturn(pipelineNames); Collection<PipelineKey> result = service.getPipelines(providerTypeKey); assertEquals(pipelineKeys, result); }
|
RuntimeServiceImpl implements RuntimeService { @Override public PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey, final String runtimeName, final PipelineKey pipelineKey, final Map<String, String> params) { checkNotNull("providerKey", providerKey); checkNotNull("runtimeName", runtimeName); checkNotNull("pipelineKey", pipelineKey); validateForCreateRuntime(providerKey, runtimeName); try { final Input input = PipelineInputBuilder.newInstance() .withRuntimeName(runtimeName) .withProvider(providerKey) .withParams(params) .build(); return new PipelineExecutionTraceKey(pipelineService.runPipeline(pipelineKey.getId(), input, true)); } catch (Exception e) { logger.error("Runtime creation failed.", e); throw ExceptionUtilities.handleException(e); } } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testCreateRuntimeSuccessful() { Provider provider = mock(Provider.class); ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); ProviderKey providerKey = new ProviderKey(providerTypeKey, PROVIDER_ID); Map<String, String> params = PipelineInputBuilderTest.mockParams(PARAMS_COUNT); List<RuntimeQueryResultItem> items = mock(List.class); when(providerService.getProvider(providerKey)).thenReturn(provider); when(runtimeProvisioningService.executeQuery(RuntimeQueryBuilder.newInstance() .withRuntimeName(RUNTIME_ID) .build())).thenReturn(items); when(items.isEmpty()).thenReturn(true); Input expectedInput = PipelineInputBuilder.newInstance() .withProvider(providerKey) .withRuntimeName(RUNTIME_ID) .withParams(params).build(); service.createRuntime(providerKey, RUNTIME_ID, PIPELINE_KEY, params); verify(pipelineService, times(1)).runPipeline(PIPELINE, expectedInput, true); }
@Test public void testCreateRuntimeWhenProviderNotExists() { ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); ProviderKey providerKey = new ProviderKey(providerTypeKey, PROVIDER_ID); expectedException.expectMessage("No provider was found for providerKey: " + providerKey); service.createRuntime(providerKey, RUNTIME_ID, PIPELINE_KEY, null); verify(pipelineService, never()).runPipeline(anyString(), any(Input.class), eq(true)); }
@Test public void testCreateRuntimeWhenProviderExistsButRuntimeNameExitsts() { Provider provider = mock(Provider.class); ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); ProviderKey providerKey = new ProviderKey(providerTypeKey, PROVIDER_ID); List<RuntimeQueryResultItem> items = mock(List.class); when(providerService.getProvider(providerKey)).thenReturn(provider); when(runtimeProvisioningService.executeQuery(RuntimeQueryBuilder.newInstance() .withRuntimeName(RUNTIME_ID) .build())).thenReturn(items); when(items.isEmpty()).thenReturn(false); expectedException.expectMessage("A runtime with the given name already exists: " + RUNTIME_ID); service.createRuntime(providerKey, RUNTIME_ID, PIPELINE_KEY, mock(Map.class)); verify(pipelineService, never()).runPipeline(anyString(), any(Input.class), eq(true)); }
@Test public void testCreateRuntimeWhenUnExpectedError() { Provider provider = mock(Provider.class); ProviderTypeKey providerTypeKey = new ProviderTypeKey(PROVIDER_NAME, PROVIDER_VERSION); ProviderKey providerKey = new ProviderKey(providerTypeKey, PROVIDER_ID); when(providerService.getProvider(providerKey)).thenReturn(provider); when(pipelineService.runPipeline(anyString(), any(Input.class), eq(true))).thenThrow(new RuntimeException(ERROR_MESSAGE)); expectedException.expectMessage(ERROR_MESSAGE); service.createRuntime(providerKey, "irrelevant for the test", mock(PipelineKey.class), mock(Map.class)); }
|
RuntimeServiceImpl implements RuntimeService { @Override public void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey) { checkNotNull("pipelineExecutionTraceKey", pipelineExecutionTraceKey); pipelineService.stopPipelineExecution(pipelineExecutionTraceKey.getId()); pipelineExecutionChangeEvent.fire(new PipelineExecutionChangeEvent(PipelineExecutionChange.STOPPED, pipelineExecutionTraceKey)); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testStopPipelineExecution() { PipelineExecutionTraceKey pipelineExecutionTraceKey = new PipelineExecutionTraceKey(PIPELINE_EXECUTION_ID); service.stopPipelineExecution(pipelineExecutionTraceKey); verify(pipelineService, times(1)).stopPipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineExecutionChangeEvent, times(1)).fire(new PipelineExecutionChangeEvent(PipelineExecutionChange.STOPPED, pipelineExecutionTraceKey)); }
|
RuntimeServiceImpl implements RuntimeService { @Override public void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey) { checkNotNull("pipelineExecutionTraceKey", pipelineExecutionTraceKey); pipelineService.deletePipelineExecution(pipelineExecutionTraceKey.getId()); pipelineExecutionChangeEvent.fire(new PipelineExecutionChangeEvent(PipelineExecutionChange.DELETED, pipelineExecutionTraceKey)); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testDeletePipelineExecution() { PipelineExecutionTraceKey pipelineExecutionTraceKey = new PipelineExecutionTraceKey(PIPELINE_EXECUTION_ID); service.deletePipelineExecution(pipelineExecutionTraceKey); verify(pipelineService, times(1)).deletePipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineExecutionChangeEvent, times(1)).fire(new PipelineExecutionChangeEvent(PipelineExecutionChange.DELETED, pipelineExecutionTraceKey)); }
|
RuntimeServiceImpl implements RuntimeService { @Override public void stopRuntime(final RuntimeKey runtimeKey) { checkNotNull("runtimeKey", runtimeKey); runtimeProvisioningService.stopRuntime(runtimeKey.getId()); runtimeChangeEvent.fire(new RuntimeChangeEvent(RuntimeChange.STOPPED, runtimeKey)); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testStopRuntime() { ProviderKey providerKey = mock(ProviderKey.class); RuntimeKey runtimeKey = new RuntimeKey(providerKey, RUNTIME_ID); service.stopRuntime(runtimeKey); verify(runtimeProvisioningService, times(1)).stopRuntime(RUNTIME_ID); verify(runtimeChangeEvent, times(1)).fire(new RuntimeChangeEvent(RuntimeChange.STOPPED, runtimeKey)); }
|
RuntimeServiceImpl implements RuntimeService { @Override public void startRuntime(final RuntimeKey runtimeKey) { checkNotNull("runtimeKey", runtimeKey); runtimeProvisioningService.startRuntime(runtimeKey.getId()); runtimeChangeEvent.fire(new RuntimeChangeEvent(RuntimeChange.STARTED, runtimeKey)); } RuntimeServiceImpl(); @Inject RuntimeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final PipelineServiceBackend pipelineService,
final ProviderService providerService,
final Event<RuntimeChangeEvent> runtimeChangeEvent,
final Event<PipelineExecutionChangeEvent> pipelineExecutionChangeEvent); @Override Collection<RuntimeListItem> getRuntimeItems(final ProviderKey providerKey); @Override RuntimeListItem getRuntimeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override RuntimeListItem getRuntimeItem(final RuntimeKey runtimeKey); @Override Collection<PipelineKey> getPipelines(final ProviderTypeKey providerTypeKey); @Override PipelineExecutionTraceKey createRuntime(final ProviderKey providerKey,
final String runtimeName,
final PipelineKey pipelineKey,
final Map<String, String> params); @Override void stopPipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void deletePipelineExecution(final PipelineExecutionTraceKey pipelineExecutionTraceKey); @Override void stopRuntime(final RuntimeKey runtimeKey); @Override void startRuntime(final RuntimeKey runtimeKey); @Override void deleteRuntime(final RuntimeKey runtimeKey,
final boolean forced); }
|
@Test public void testStartRuntime() { ProviderKey providerKey = mock(ProviderKey.class); RuntimeKey runtimeKey = new RuntimeKey(providerKey, RUNTIME_ID); service.startRuntime(runtimeKey); verify(runtimeProvisioningService, times(1)).startRuntime(RUNTIME_ID); verify(runtimeChangeEvent, times(1)).fire(new RuntimeChangeEvent(RuntimeChange.STARTED, runtimeKey)); }
|
EditablePopupHeaderMetaData implements EditableHeaderMetaData { @Override public void edit(final GridBodyCellEditContext context) { final int uiRowIndex = context.getRowIndex(); final int uiColumnIndex = context.getColumnIndex(); final double cellWidth = context.getCellWidth(); final double cellHeight = context.getCellHeight(); final double absoluteCellX = context.getAbsoluteCellX(); final double absoluteCellY = context.getAbsoluteCellY(); editor.bind(getPresenter(), uiRowIndex, uiColumnIndex); final double[] dxy = {absoluteCellX + cellWidth / 2, absoluteCellY + cellHeight / 2}; final Optional<Point2D> rx = context.getRelativeLocation(); rx.ifPresent(r -> { dxy[0] = r.getX(); dxy[1] = r.getY(); }); cellEditorControls.show(editor, (int) (dxy[0]), (int) (dxy[1])); } EditablePopupHeaderMetaData(final CellEditorControlsView.Presenter cellEditorControls,
final E editor); @Override void setColumnGroup(final String columnGroup); @Override void setTitle(final String title); @Override void edit(final GridBodyCellEditContext context); @Override void destroyResources(); }
|
@Test public void testEditWithRelationLocation() { final GridBodyCellEditContext context = new GridBodyCellEditContext(ABSOLUTE_CELL_X, ABSOLUTE_CELL_Y, CELL_WIDTH, CELL_HEIGHT, CLIP_MIN_Y, CLIP_MIN_X, ROW_INDEX, COLUMN_INDEX, IS_FLOATING, transform, renderer, Optional.of(new Point2D(RELATIVE_X, RELATIVE_Y))); header.edit(context); verify(editor).bind(eq(gridWidget), eq(ROW_INDEX), eq(COLUMN_INDEX)); verify(cellEditorControls).show(eq(editor), eq((int) RELATIVE_X), eq((int) RELATIVE_Y)); }
@Test public void testEditWithNoRelationLocation() { final GridBodyCellEditContext context = new GridBodyCellEditContext(ABSOLUTE_CELL_X, ABSOLUTE_CELL_Y, CELL_WIDTH, CELL_HEIGHT, CLIP_MIN_Y, CLIP_MIN_X, ROW_INDEX, COLUMN_INDEX, IS_FLOATING, transform, renderer, Optional.empty()); header.edit(context); verify(editor).bind(eq(gridWidget), eq(ROW_INDEX), eq(COLUMN_INDEX)); verify(cellEditorControls).show(eq(editor), eq((int) (ABSOLUTE_CELL_X + CELL_WIDTH / 2)), eq((int) (ABSOLUTE_CELL_Y + CELL_HEIGHT / 2))); }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public Collection<ProviderType> getAvailableProviderTypes() { List<ProviderType> result = new ArrayList<>(); List<org.guvnor.ala.runtime.providers.ProviderType> providers = runtimeProvisioningService.getProviderTypes(0, 100, PROVIDER_TYPE_NAME_SORT, true); if (providers != null) { providers.forEach(providerType -> result.add(new ProviderType(new ProviderTypeKey(providerType.getProviderTypeName(), providerType.getVersion()), providerType.getProviderTypeName())) ); } return result; } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testGetAvailableProviders() { Collection<ProviderType> result = service.getAvailableProviderTypes(); assertEquals(PROVIDER_TYPES_COUNT, result.size()); int i = 0; for (ProviderType providerType : result) { assertNotNull(providerType.getKey()); assertEquals(providerTypesSpi.get(i).getProviderTypeName(), providerType.getKey().getId()); assertEquals(providerTypesSpi.get(i).getVersion(), providerType.getKey().getVersion()); i++; } }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public ProviderType getProviderType(final ProviderTypeKey providerTypeKey) { checkNotNull("providerTypeKey", providerTypeKey); return getAvailableProviderTypes().stream() .filter(providerType -> providerType.getKey().equals(providerTypeKey)) .findFirst().orElse(null); } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testGetProviderTypeExisting() { org.guvnor.ala.runtime.providers.ProviderType providerTypeSpi = providerTypesSpi.get(2); ProviderTypeKey providerTypeKey = new ProviderTypeKey(providerTypeSpi.getProviderTypeName(), providerTypeSpi.getVersion()); ProviderType providerType = service.getProviderType(providerTypeKey); assertNotNull(providerType); assertEquals(providerTypeSpi.getProviderTypeName(), providerType.getKey().getId()); assertEquals(providerTypeSpi.getVersion(), providerType.getKey().getVersion()); }
@Test public void testGetProviderTypeNotExisting() { ProviderTypeKey providerTypeKey = new ProviderTypeKey("NonExisting", "NonExisting"); ProviderType providerType = service.getProviderType(providerTypeKey); assertNull(providerType); }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public Collection<ProviderType> getEnabledProviderTypes() { return getProviderTypesStatus().entrySet().stream() .filter(entry -> ProviderTypeStatus.ENABLED.equals(entry.getValue())) .map(Map.Entry::getKey) .collect(Collectors.toList()); } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testGetEnabledProviderTypes() { pickSomeProviders(); pickedProviderTypes.forEach(providerType -> provisioningPreferences.getProviderTypeEnablements().put(providerType, Boolean.TRUE)); Collection<ProviderType> result = service.getEnabledProviderTypes(); assertEquals(pickedProviderTypes.size(), result.size()); pickedProviderTypes.forEach(providerType -> assertTrue(result.contains(providerType))); verify(provisioningPreferences, times(1)).load(); }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public void enableProviderTypes(final Collection<ProviderType> providerTypes) { checkNotEmpty("providerTypes", providerTypes); providerTypes.forEach(providerType -> enableProviderType(providerType, true)); } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testEnableProviderTypes() { pickSomeProviders(); pickedProviderTypes.forEach(providerType -> provisioningPreferences.getProviderTypeEnablements().put(providerType, Boolean.FALSE)); service.enableProviderTypes(pickedProviderTypes); pickedProviderTypes.forEach(providerType -> assertTrue(provisioningPreferences.getProviderTypeEnablements().get(providerType))); verify(provisioningPreferences, times(pickedProviderTypes.size())).save(preferenceScope); }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public void disableProviderType(final ProviderType providerType) { checkNotNull("providerType", providerType); enableProviderType(providerType, false); } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testDisableProviderType() { pickSomeProviders(); pickSomeProviders(); pickedProviderTypes.forEach(providerType -> provisioningPreferences.getProviderTypeEnablements().put(providerType, Boolean.TRUE)); ProviderType providerTypeToDisable = pickedProviderTypes.get(0); service.disableProviderType(providerTypeToDisable); assertFalse(provisioningPreferences.getProviderTypeEnablements().get(providerTypeToDisable)); verify(provisioningPreferences, times(1)).save(preferenceScope); }
|
ProviderTypeServiceImpl implements ProviderTypeService { @Override public Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus() { final Map<ProviderType, ProviderTypeStatus> result = new HashMap<>(); readProviderTypeEnablements().forEach((providerType, isEnabled) -> result.put(providerType, Boolean.TRUE.equals(isEnabled) ? ProviderTypeStatus.ENABLED : ProviderTypeStatus.DISABLED) ); getAvailableProviderTypes().forEach(providerType -> { if (!result.containsKey(providerType)) { result.put(providerType, ProviderTypeStatus.DISABLED); } }); return result; } ProviderTypeServiceImpl(); @Inject ProviderTypeServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProvisioningPreferences provisioningPreferences,
final PreferenceScopeFactory scopeFactory); @Override Collection<ProviderType> getAvailableProviderTypes(); @Override ProviderType getProviderType(final ProviderTypeKey providerTypeKey); @Override Collection<ProviderType> getEnabledProviderTypes(); @Override void enableProviderTypes(final Collection<ProviderType> providerTypes); @Override void disableProviderType(final ProviderType providerType); @Override Map<ProviderType, ProviderTypeStatus> getProviderTypesStatus(); }
|
@Test public void testGetProviderTypesStatus() { Map<ProviderType, ProviderTypeStatus> initialStatusMap = service.getProviderTypesStatus(); assertEquals(PROVIDER_TYPES_COUNT, initialStatusMap.size()); initialStatusMap.values().forEach(status -> assertEquals(status, ProviderTypeStatus.DISABLED)); pickSomeProviders(); service.enableProviderTypes(pickedProviderTypes); Map<ProviderType, ProviderTypeStatus> currentStatusMap = service.getProviderTypesStatus(); assertEquals(PROVIDER_TYPES_COUNT, currentStatusMap.size()); pickedProviderTypes.forEach(enabledProvider -> assertEquals(ProviderTypeStatus.ENABLED, currentStatusMap.get(pickedProviderTypes.get(0)))); long expectedDisabled = PROVIDER_TYPES_COUNT - pickedProviderTypes.size(); long currentDisabled = currentStatusMap.values().stream() .filter(status -> status == ProviderTypeStatus.DISABLED).count(); assertEquals(expectedDisabled, currentDisabled); }
|
BackendProviderHandlerRegistry extends AbstractProviderHandlerRegistry<BackendProviderHandler> { public BackendProviderHandler ensureHandler(ProviderTypeKey providerTypeKey) { final BackendProviderHandler handler = getProviderHandler(providerTypeKey); if (handler == null) { throw new RuntimeException("BackendProviderHandler was not found for providerTypeKey: " + providerTypeKey); } return handler; } BackendProviderHandlerRegistry(); @Inject BackendProviderHandlerRegistry(final @Any Instance<BackendProviderHandler> handlerInstance); BackendProviderHandler ensureHandler(ProviderTypeKey providerTypeKey); }
|
@Test public void testEnsureHandlerForRegisteredProviderType() throws Exception { ProviderTypeKey providerTypeKey = expectedKeys.get(0); BackendProviderHandler handler = ((BackendProviderHandlerRegistry) handlerRegistry).ensureHandler(providerTypeKey); assertEquals(expectedHandlers.get(0), handler); }
@Test public void testEnsureHandlerForNonRegisteredProviderType() throws Exception { ProviderTypeKey providerTypeKey = mock(ProviderTypeKey.class); expectedException.expectMessage("BackendProviderHandler was not found for providerTypeKey: " + providerTypeKey); ((BackendProviderHandlerRegistry) handlerRegistry).ensureHandler(providerTypeKey); }
|
PipelineInputBuilder { public Input build() { final Input input = new Input(); if (runtimeName != null) { input.put(RuntimeConfig.RUNTIME_NAME, runtimeName); } if (providerKey != null) { input.put(ProviderConfig.PROVIDER_NAME, providerKey.getId()); } if (params != null) { input.putAll(params); } return input; } private PipelineInputBuilder(); static PipelineInputBuilder newInstance(); PipelineInputBuilder withRuntimeName(final String runtimeName); PipelineInputBuilder withProvider(final ProviderKey providerKey); PipelineInputBuilder withParams(final Map<String, String> params); Input build(); }
|
@Test public void testBuild() { Input result = PipelineInputBuilder.newInstance() .withProvider(providerKey) .withParams(params) .withRuntimeName(RUNTIME).build(); assertNotNull(result); assertEquals(RUNTIME, result.get(RuntimeConfig.RUNTIME_NAME)); assertEquals(PROVIDER, result.get(ProviderConfig.PROVIDER_NAME)); params.forEach((name, value) -> assertEquals(value, result.get(name))); }
|
ProviderConverterImpl implements ProviderConverter { @Override public Provider toModel(org.guvnor.ala.runtime.providers.Provider provider) { Provider result = null; if (provider != null) { ProviderTypeKey providerTypeKey = new ProviderTypeKey(provider.getProviderType().getProviderTypeName(), provider.getProviderType().getVersion()); ProviderKey providerKey = new ProviderKey(providerTypeKey, provider.getId()); final BackendProviderHandler handler = handlerRegistry.ensureHandler(providerTypeKey); @SuppressWarnings("unchecked") final ProviderConfiguration providerConfiguration = (ProviderConfiguration) handler.getProviderConfigConverter().toModel(provider.getConfig()); result = new Provider(providerKey, providerConfiguration); } return result; } ProviderConverterImpl(final BackendProviderHandlerRegistry handlerRegistry); @Override Class<Provider> getModelType(); @Override Class<org.guvnor.ala.runtime.providers.Provider> getDomainType(); @Override org.guvnor.ala.runtime.providers.Provider toDomain(Provider modelValue); @Override Provider toModel(org.guvnor.ala.runtime.providers.Provider provider); }
|
@Test public void testToModelWhenHandlerNotConfigured() { when(handlerRegistry.ensureHandler(providerTypeKey)).thenThrow(new RuntimeException(ERROR_MESSAGE)); expectedException.expectMessage(ERROR_MESSAGE); converter.toModel(provider); }
@Test public void testToModelWhenHandlerIsConfigured() { when(handlerRegistry.ensureHandler(providerTypeKey)).thenReturn(providerHandler); when(providerHandler.getProviderConfigConverter()).thenReturn(providerConfigConverter); when(providerConfigConverter.toModel(providerConfig)).thenReturn(providerConfiguration); Provider result = converter.toModel(provider); assertNotNull(result); assertEquals(PROVIDER_ID, result.getKey().getId()); assertEquals(PROVIDER_TYPE_NAME, result.getKey().getProviderTypeKey().getId()); assertEquals(PROVIDER_VERSION, result.getKey().getProviderTypeKey().getVersion()); assertEquals(result.getConfiguration(), providerConfiguration); }
|
ProviderConverterFactoryImpl implements ProviderConverterFactory { @Override public ProviderConfigConverter getProviderConfigConverter(final ProviderTypeKey providerTypeKey) { final BackendProviderHandler handler = handlerRegistry.ensureHandler(providerTypeKey); return handler.getProviderConfigConverter(); } ProviderConverterFactoryImpl(); @Inject ProviderConverterFactoryImpl(final BackendProviderHandlerRegistry handlerRegistry); @Override ProviderConfigConverter getProviderConfigConverter(final ProviderTypeKey providerTypeKey); @Override ProviderConverter getProviderConverter(); }
|
@Test public void testGetProviderConfigConverterWhenHandlerConfigured() { when(handlerRegistry.ensureHandler(providerTypeKey)).thenReturn(providerHandler); when(providerHandler.getProviderConfigConverter()).thenReturn(configConverter); assertEquals(configConverter, converterFactory.getProviderConfigConverter(providerTypeKey)); }
@Test public void testGetProviderConfigConverterWhenHandlerNotConfigured() { when(handlerRegistry.ensureHandler(providerTypeKey)).thenThrow(new RuntimeException(ERROR_MESSAGE)); expectedException.expectMessage(ERROR_MESSAGE); converterFactory.getProviderConfigConverter(providerTypeKey); }
|
ProviderConverterFactoryImpl implements ProviderConverterFactory { @Override public ProviderConverter getProviderConverter() { return providerConverter; } ProviderConverterFactoryImpl(); @Inject ProviderConverterFactoryImpl(final BackendProviderHandlerRegistry handlerRegistry); @Override ProviderConfigConverter getProviderConfigConverter(final ProviderTypeKey providerTypeKey); @Override ProviderConverter getProviderConverter(); }
|
@Test public void testGetProviderConverter() { assertNotNull(converterFactory.getProviderConverter()); }
|
ProvisioningValidationServiceImpl implements ProvisioningValidationService { @Override public boolean isValidContainerName(final String containerName) { return containerName != null && containerName.matches("[A-Za-z0-9_\\-.:]+"); } ProvisioningValidationServiceImpl(); @Override boolean isValidContainerName(final String containerName); }
|
@Test public void testIsValidContainerNameForValidNames() { Arrays.stream(validContainerNames).forEach(name -> assertTrue(service.isValidContainerName(name))); }
@Test public void testIsValidContainerNameForInvalidNames() { Arrays.stream(invalidContainerNames).forEach(name -> assertFalse(service.isValidContainerName(name))); }
|
ProviderServiceImpl implements ProviderService { @Override public Collection<Provider> getProviders(final ProviderType providerType) { checkNotNull("providerType", providerType); return getAllProviders().stream() .filter(provider -> provider.getKey().getProviderTypeKey().equals(providerType.getKey())) .collect(toList()); } ProviderServiceImpl(); @Inject ProviderServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProviderConverterFactory providerConverterFactory); @Override Collection<Provider> getProviders(final ProviderType providerType); @Override Collection<ProviderKey> getProvidersKey(final ProviderType providerType); @Override void createProvider(final ProviderType providerType,
final ProviderConfiguration configuration); @Override void deleteProvider(final ProviderKey providerKey); @Override Provider getProvider(final ProviderKey providerKey); }
|
@Test public void testGetProviders() { Collection<Provider> result = service.getProviders(providerType); assertEquals(providers, result); }
|
ProviderServiceImpl implements ProviderService { @Override public Collection<ProviderKey> getProvidersKey(final ProviderType providerType) { return getProviders(providerType).stream() .map(AbstractHasKeyObject::getKey) .collect(toList()); } ProviderServiceImpl(); @Inject ProviderServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProviderConverterFactory providerConverterFactory); @Override Collection<Provider> getProviders(final ProviderType providerType); @Override Collection<ProviderKey> getProvidersKey(final ProviderType providerType); @Override void createProvider(final ProviderType providerType,
final ProviderConfiguration configuration); @Override void deleteProvider(final ProviderKey providerKey); @Override Provider getProvider(final ProviderKey providerKey); }
|
@Test public void testGetProvidersKey() { Collection<ProviderKey> result = service.getProvidersKey(providerType); assertEquals(providerKeys, result); }
|
ProviderServiceImpl implements ProviderService { @Override public void createProvider(final ProviderType providerType, final ProviderConfiguration configuration) { checkNotNull("providerType", providerType); checkNotNull("providerType.providerTypeKey", providerType.getKey()); checkNotNull("configuration", configuration); checkNotEmpty("configuration.values", configuration.getValues()); validateForCreateProvider(configuration); @SuppressWarnings("unchecked") final ProviderConfig providerConfig = (ProviderConfig) providerConverterFactory.getProviderConfigConverter(providerType.getKey()).toDomain(configuration); runtimeProvisioningService.registerProvider(providerConfig); } ProviderServiceImpl(); @Inject ProviderServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProviderConverterFactory providerConverterFactory); @Override Collection<Provider> getProviders(final ProviderType providerType); @Override Collection<ProviderKey> getProvidersKey(final ProviderType providerType); @Override void createProvider(final ProviderType providerType,
final ProviderConfiguration configuration); @Override void deleteProvider(final ProviderKey providerKey); @Override Provider getProvider(final ProviderKey providerKey); }
|
@Test public void testCreateProvider() { prepareConfigurationForCreate(); when(providerConfiguration.getId()).thenReturn(PROVIDER_ID); service.createProvider(providerType, providerConfiguration); verify(runtimeProvisioningService, times(1)).registerProvider(providerConfig); }
@Test public void testCreateProviderExisting() { prepareConfigurationForCreate(); String existingId = providers.get(1).getKey().getId(); when(providerConfiguration.getId()).thenReturn(existingId); expectedException.expectMessage("A provider with the given name already exists: " + existingId); service.createProvider(providerType, providerConfiguration); verify(runtimeProvisioningService, never()).registerProvider(any(ProviderConfig.class)); }
|
EditablePopupHeaderMetaData implements EditableHeaderMetaData { @Override public void destroyResources() { editor.hide(); } EditablePopupHeaderMetaData(final CellEditorControlsView.Presenter cellEditorControls,
final E editor); @Override void setColumnGroup(final String columnGroup); @Override void setTitle(final String title); @Override void edit(final GridBodyCellEditContext context); @Override void destroyResources(); }
|
@Test public void testDestroyResources() { header.destroyResources(); verify(editor).hide(); }
|
ProviderServiceImpl implements ProviderService { @Override public void deleteProvider(final ProviderKey providerKey) { runtimeProvisioningService.unregisterProvider(providerKey.getId()); } ProviderServiceImpl(); @Inject ProviderServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProviderConverterFactory providerConverterFactory); @Override Collection<Provider> getProviders(final ProviderType providerType); @Override Collection<ProviderKey> getProvidersKey(final ProviderType providerType); @Override void createProvider(final ProviderType providerType,
final ProviderConfiguration configuration); @Override void deleteProvider(final ProviderKey providerKey); @Override Provider getProvider(final ProviderKey providerKey); }
|
@Test public void testDeleteProvider() { ProviderKey providerKey = mock(ProviderKey.class); when(providerKey.getId()).thenReturn(PROVIDER_ID); service.deleteProvider(providerKey); verify(runtimeProvisioningService, times(1)).unregisterProvider(PROVIDER_ID); }
|
ProviderServiceImpl implements ProviderService { @Override public Provider getProvider(final ProviderKey providerKey) { List<org.guvnor.ala.runtime.providers.Provider> providers = runtimeProvisioningService.getProviders(0, 1000, PROVIDER_TYPE_NAME_SORT, true); Optional<Provider> result = Optional.empty(); if (providers != null) { result = providers.stream() .filter(provider -> provider.getId().equals(providerKey.getId())) .map(this::convert) .findFirst(); } return result.orElse(null); } ProviderServiceImpl(); @Inject ProviderServiceImpl(final RuntimeProvisioningServiceBackend runtimeProvisioningService,
final ProviderConverterFactory providerConverterFactory); @Override Collection<Provider> getProviders(final ProviderType providerType); @Override Collection<ProviderKey> getProvidersKey(final ProviderType providerType); @Override void createProvider(final ProviderType providerType,
final ProviderConfiguration configuration); @Override void deleteProvider(final ProviderKey providerKey); @Override Provider getProvider(final ProviderKey providerKey); }
|
@Test public void testGetProviderExisting() { org.guvnor.ala.runtime.providers.Provider providerSpi = providersSpi.get(2); ProviderTypeKey providerTypeKey = new ProviderTypeKey(providerSpi.getProviderType().getProviderTypeName(), providerSpi.getProviderType().getVersion()); ProviderKey providerKey = new ProviderKey(providerTypeKey, providerSpi.getId()); Provider provider = service.getProvider(providerKey); assertNotNull(provider); assertEquals(providers.get(2).getKey(), provider.getKey()); }
@Test public void testGetProviderNotExisting() { ProviderTypeKey providerTypeKey = new ProviderTypeKey("not exist", "not exist"); ProviderKey providerKey = new ProviderKey(providerTypeKey, "not exist"); Provider provider = service.getProvider(providerKey); assertNull(provider); }
|
SourceServiceImpl implements SourceService { @Override public Collection<String> getOrganizationUnits() { return organizationalUnitService.getOrganizationalUnits().stream() .map(OrganizationalUnit::getName) .collect(Collectors.toList()); } SourceServiceImpl(); @Inject SourceServiceImpl(OrganizationalUnitService organizationalUnitService,
RepositoryService repositoryService,
ModuleService<? extends Module> moduleService,
AuthorizationManager authorizationManager,
User identity); @Override Collection<String> getOrganizationUnits(); @Override Collection<String> getRepositories(final String organizationalUnit); @Override Collection<String> getBranches(final Space space, final String repositoryName); @Override Collection<Module> getModules(final Space space,
final String repositoryAlias,
final String branchName); }
|
@Test public void testGetOrganizationalUnits() { when(organizationalUnitService.getOrganizationalUnits()).thenReturn(organizationalUnits); List<String> expectedResult = organizationalUnits.stream() .map(OrganizationalUnit::getName) .collect(Collectors.toList()); Collection<String> result = service.getOrganizationUnits(); assertEquals(expectedResult, result); }
|
SourceServiceImpl implements SourceService { @Override public Collection<String> getRepositories(final String organizationalUnit) { checkNotNull("organizationalUnit", organizationalUnit); OrganizationalUnit ou = organizationalUnitService.getOrganizationalUnit(organizationalUnit); if (ou == null) { return new ArrayList<>(); } else { return organizationalUnitService.getOrganizationalUnit(organizationalUnit) .getRepositories() .stream() .filter(repository -> authorizationManager.authorize(repository, identity)) .map(Repository::getAlias) .collect(Collectors.toList()); } } SourceServiceImpl(); @Inject SourceServiceImpl(OrganizationalUnitService organizationalUnitService,
RepositoryService repositoryService,
ModuleService<? extends Module> moduleService,
AuthorizationManager authorizationManager,
User identity); @Override Collection<String> getOrganizationUnits(); @Override Collection<String> getRepositories(final String organizationalUnit); @Override Collection<String> getBranches(final Space space, final String repositoryName); @Override Collection<Module> getModules(final Space space,
final String repositoryAlias,
final String branchName); }
|
@Test public void testGetRepositories() { List<Repository> repositories = mockRepositories("RepoName.", REPOSITORIES_SIZE); OrganizationalUnit organizationalUnit = mock(OrganizationalUnit.class); when(organizationalUnit.getName()).thenReturn(OU_NAME); when(organizationalUnitService.getOrganizationalUnit(OU_NAME)).thenReturn(null); Collection<String> result = service.getRepositories(OU_NAME); assertTrue(result.isEmpty()); when(organizationalUnitService.getOrganizationalUnit(OU_NAME)).thenReturn(organizationalUnit); when(organizationalUnit.getRepositories()).thenReturn(repositories); result = service.getRepositories(OU_NAME); assertTrue(result.isEmpty()); List<Integer> authorizedIndexes = new ArrayList<>(); List<String> authorizedNames = new ArrayList<>(); authorizedIndexes.add(1); authorizedIndexes.add(4); authorizedIndexes.add(6); authorizedIndexes.forEach(index -> { when(authorizationManager.authorize(repositories.get(index), identity)).thenReturn(true); authorizedNames.add(repositories.get(index).getAlias()); }); result = service.getRepositories(OU_NAME); assertEquals(authorizedNames, result); }
|
SourceServiceImpl implements SourceService { @Override public Collection<String> getBranches(final Space space, final String repositoryName) { checkNotNull("repositoryName", repositoryName); final Repository repository = repositoryService.getRepositoryFromSpace(space, repositoryName); return repository != null ? toBranchNames(repository.getBranches()) : new ArrayList<>(); } SourceServiceImpl(); @Inject SourceServiceImpl(OrganizationalUnitService organizationalUnitService,
RepositoryService repositoryService,
ModuleService<? extends Module> moduleService,
AuthorizationManager authorizationManager,
User identity); @Override Collection<String> getOrganizationUnits(); @Override Collection<String> getRepositories(final String organizationalUnit); @Override Collection<String> getBranches(final Space space, final String repositoryName); @Override Collection<Module> getModules(final Space space,
final String repositoryAlias,
final String branchName); }
|
@Test public void testGetBranches() { final List<Branch> branches = new ArrayList<>(); branches.add(new Branch("branch1", mock(Path.class))); branches.add(new Branch("branch2", mock(Path.class))); branches.add(new Branch("branch3", mock(Path.class))); Repository repository = mock(Repository.class); when(repository.getBranches()).thenReturn(branches); when(repositoryService.getRepositoryFromSpace(SPACE, REPO_NAME)).thenReturn(repository); final Collection<String> result = service.getBranches(SPACE, REPO_NAME); final List<String> originalBranchNames = new ArrayList<>(); for (final Branch branch : branches) { originalBranchNames.add(branch.getName()); } assertEquals(originalBranchNames, result); }
|
SourceServiceImpl implements SourceService { @Override public Collection<Module> getModules(final Space space, final String repositoryAlias, final String branchName) { checkNotNull("repositoryAlias", repositoryAlias); checkNotNull("branchName", branchName); final Repository repository = repositoryService.getRepositoryFromSpace(space, repositoryAlias); if (repository == null) { return new ArrayList<>(); } else { final Optional<Branch> branch = repository.getBranch(branchName); if (branch.isPresent()) { return moduleService.getAllModules(branch.get()); } else { return new ArrayList<>(); } } } SourceServiceImpl(); @Inject SourceServiceImpl(OrganizationalUnitService organizationalUnitService,
RepositoryService repositoryService,
ModuleService<? extends Module> moduleService,
AuthorizationManager authorizationManager,
User identity); @Override Collection<String> getOrganizationUnits(); @Override Collection<String> getRepositories(final String organizationalUnit); @Override Collection<String> getBranches(final Space space, final String repositoryName); @Override Collection<Module> getModules(final Space space,
final String repositoryAlias,
final String branchName); }
|
@Test public void testProjects() { final Repository repository = mock(Repository.class); final Branch branch = new Branch(BRANCH_NAME, mock(Path.class)); doReturn(Optional.of(branch)).when(repository).getBranch(eq(BRANCH_NAME)); @SuppressWarnings("unchecked") final Set<Module> modules = mock(Set.class); when(repositoryService.getRepositoryFromSpace(SPACE, REPO_NAME)).thenReturn(repository); when(moduleService.getAllModules(branch)).thenReturn(modules); final Collection<Module> result = service.getModules(SPACE, REPO_NAME, BRANCH_NAME); assertEquals(modules, result); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void beforePipelineExecution(BeforePipelineExecutionEvent bpee) { pipelineStatusChangeEvent.fire(new PipelineStatusChangeEvent(new PipelineExecutionTraceKey(bpee.getExecutionId()), PipelineStatus.RUNNING)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testBeforePipelineExecution() { listener.beforePipelineExecution(new BeforePipelineExecutionEvent(EXECUTION_ID, pipeline)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.RUNNING)); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void afterPipelineExecution(AfterPipelineExecutionEvent apee) { pipelineStatusChangeEvent.fire(new PipelineStatusChangeEvent(new PipelineExecutionTraceKey(apee.getExecutionId()), PipelineStatus.FINISHED)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testAfterPipelineExecution() { listener.afterPipelineExecution(new AfterPipelineExecutionEvent(EXECUTION_ID, pipeline)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.FINISHED)); }
|
EditableTextHeaderMetaData implements EditableHeaderMetaData { @Override public String getTitle() { return titleGetter.get(); } EditableTextHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<W, E> factory); EditableTextHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<W, E> factory,
final String columnGroup); @Override String getTitle(); @Override void setTitle(final String title); @Override String getColumnGroup(); @Override void setColumnGroup(final String columnGroup); @Override void destroyResources(); @Override void edit(final GridBodyCellEditContext context); @Override GridCellEditAction getSupportedEditAction(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void checkGetTitleWithHasName() { hasName = Optional.of(new MockHasName("name")); assertEquals("name", header.getTitle()); }
@Test public void checkGetTitleWithoutHasName() { hasName = Optional.empty(); assertEquals("", header.getTitle()); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void beforeStageExecution(BeforeStageExecutionEvent bsee) { stageStatusChangeEvent.fire(new StageStatusChangeEvent(new PipelineExecutionTraceKey(bsee.getExecutionId()), bsee.getStage().getName(), PipelineStatus.RUNNING)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testBeforeStageExecution() { listener.beforeStageExecution(new BeforeStageExecutionEvent(EXECUTION_ID, pipeline, stage)); verify(stageStatusChangeEvent, times(1)).fire(new StageStatusChangeEvent(traceKey, STAGE_NAME, PipelineStatus.RUNNING)); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void onStageError(OnErrorStageExecutionEvent oesee) { stageStatusChangeEvent.fire(new StageStatusChangeEvent(new PipelineExecutionTraceKey(oesee.getExecutionId()), oesee.getStage().getName(), PipelineStatus.ERROR)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testOnStageError() { listener.onStageError(new OnErrorStageExecutionEvent(EXECUTION_ID, pipeline, stage, throwable)); verify(stageStatusChangeEvent, times(1)).fire(new StageStatusChangeEvent(traceKey, STAGE_NAME, PipelineStatus.ERROR)); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void afterStageExecution(AfterStageExecutionEvent asee) { stageStatusChangeEvent.fire(new StageStatusChangeEvent(new PipelineExecutionTraceKey(asee.getExecutionId()), asee.getStage().getName(), PipelineStatus.FINISHED)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testAfterStageExecution() { listener.afterStageExecution(new AfterStageExecutionEvent(EXECUTION_ID, pipeline, stage)); verify(stageStatusChangeEvent, times(1)).fire(new StageStatusChangeEvent(traceKey, STAGE_NAME, PipelineStatus.FINISHED)); }
|
PipelineExecutionListener implements PipelineEventListener { @Override public void onPipelineError(OnErrorPipelineExecutionEvent oepee) { pipelineStatusChangeEvent.fire(new PipelineStatusChangeEvent(new PipelineExecutionTraceKey(oepee.getExecutionId()), PipelineStatus.ERROR)); } PipelineExecutionListener(); @Inject PipelineExecutionListener(final Event<PipelineStatusChangeEvent> pipelineStatusChangeEvent,
final Event<StageStatusChangeEvent> stageStatusChangeEvent); @Override void beforePipelineExecution(BeforePipelineExecutionEvent bpee); @Override void afterPipelineExecution(AfterPipelineExecutionEvent apee); @Override void beforeStageExecution(BeforeStageExecutionEvent bsee); @Override void onStageError(OnErrorStageExecutionEvent oesee); @Override void afterStageExecution(AfterStageExecutionEvent asee); @Override void onPipelineError(OnErrorPipelineExecutionEvent oepee); }
|
@Test public void testOnPipelineError() { listener.onPipelineError(new OnErrorPipelineExecutionEvent(EXECUTION_ID, pipeline, stage, throwable)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.ERROR)); }
|
ProvisioningClientValidationService { public void isValidContainerName(final String containerName, final ValidatorCallback callback) { validationService.call(result -> { if (Boolean.TRUE.equals(result)) { callback.onSuccess(); } else { callback.onFailure(); } }).isValidContainerName(containerName); } @Inject ProvisioningClientValidationService(final Caller<ProvisioningValidationService> validationService); void isValidContainerName(final String containerName,
final ValidatorCallback callback); }
|
@Test public void testIsValidContainerNameForValidName() { when(validationService.isValidContainerName(CONTAINER_NAME)).thenReturn(true); service.isValidContainerName(CONTAINER_NAME, validatorCallback); verify(validationService, times(1)).isValidContainerName(CONTAINER_NAME); verify(validatorCallback, times(1)).onSuccess(); verify(validatorCallback, never()).onFailure(); }
@Test public void testIsValidContainerNameForInvalidName() { when(validationService.isValidContainerName(CONTAINER_NAME)).thenReturn(false); service.isValidContainerName(CONTAINER_NAME, validatorCallback); verify(validationService, times(1)).isValidContainerName(CONTAINER_NAME); verify(validatorCallback, times(1)).onFailure(); verify(validatorCallback, never()).onSuccess(); }
|
ProvisioningManagementPerspective { protected void onAddNewProviderType(@Observes final AddNewProviderTypeEvent event) { providerTypeService.call((Map<ProviderType, ProviderTypeStatus> result) -> { enableProviderTypeWizard.start(buildProviderStatusList(result)); }).getProviderTypesStatus(); } @Inject ProvisioningManagementPerspective(final Caller<ProviderTypeService> providerTypeService,
final Caller<RuntimeService> runtimeService,
final EnableProviderTypeWizard enableProviderTypeWizard,
final NewProviderWizard newProviderWizard,
final NewDeployWizard newDeployWizard,
final ClientProviderHandlerRegistry handlerRegistry); @Perspective PerspectiveDefinition buildPerspective(); static final String IDENTIFIER; }
|
@Test public void testAddNewProviderType() { List<ProviderType> providerTypes = mockProviderTypeList(PROVIDER_TYPE_COUNT); Map<ProviderType, ProviderTypeStatus> providerTypeStatusMap = new HashMap<>(); providerTypes.forEach(providerType -> providerTypeStatusMap.put(providerType, mock(ProviderTypeStatus.class))); when(providerTypeService.getProviderTypesStatus()).thenReturn(providerTypeStatusMap); List<ProviderType> properlyInstalledProviderTypes = new ArrayList<>(); properlyInstalledProviderTypes.add(providerTypes.get(0)); properlyInstalledProviderTypes.add(providerTypes.get(3)); properlyInstalledProviderTypes.add(providerTypes.get(5)); properlyInstalledProviderTypes.forEach(providerType -> when(handlerRegistry.isProviderInstalled(providerType.getKey())).thenReturn(true)); perspective.onAddNewProviderType(mock(AddNewProviderTypeEvent.class)); verify(providerTypeService, times(1)).getProviderTypesStatus(); verify(enableProviderTypeWizard, times(1)).start(providerTypesCaptor.capture()); assertEquals(properlyInstalledProviderTypes.size(), providerTypesCaptor.getValue().size()); @SuppressWarnings("unchecked") List<Pair<ProviderType, ProviderTypeStatus>> capturedValues = providerTypesCaptor.getValue(); capturedValues.forEach(value -> assertTrue(properlyInstalledProviderTypes.contains(value.getK1()))); }
|
ProvisioningManagementPerspective { protected void onAddNewProvider(@Observes final AddNewProviderEvent event) { if (event.getProviderType() != null && event.getProviderType().getKey() != null) { newProviderWizard.start(event.getProviderType()); } } @Inject ProvisioningManagementPerspective(final Caller<ProviderTypeService> providerTypeService,
final Caller<RuntimeService> runtimeService,
final EnableProviderTypeWizard enableProviderTypeWizard,
final NewProviderWizard newProviderWizard,
final NewDeployWizard newDeployWizard,
final ClientProviderHandlerRegistry handlerRegistry); @Perspective PerspectiveDefinition buildPerspective(); static final String IDENTIFIER; }
|
@Test public void testAddNewProvider() { ProviderType providerType = mockProviderType(""); perspective.onAddNewProvider(new AddNewProviderEvent(providerType)); verify(newProviderWizard, times(1)).start(providerType); }
|
ProvisioningManagementPerspective { protected void onAddNewRuntime(@Observes final AddNewRuntimeEvent event) { if (event.getProvider() != null) { runtimeService.call((Collection<PipelineKey> result) -> { newDeployWizard.start(event.getProvider(), result); }).getPipelines(event.getProvider().getKey().getProviderTypeKey()); } } @Inject ProvisioningManagementPerspective(final Caller<ProviderTypeService> providerTypeService,
final Caller<RuntimeService> runtimeService,
final EnableProviderTypeWizard enableProviderTypeWizard,
final NewProviderWizard newProviderWizard,
final NewDeployWizard newDeployWizard,
final ClientProviderHandlerRegistry handlerRegistry); @Perspective PerspectiveDefinition buildPerspective(); static final String IDENTIFIER; }
|
@Test public void testAddNewRuntime() { Provider provider = new Provider(mockProviderKey(mockProviderTypeKey(""), ""), mock(ProviderConfiguration.class)); @SuppressWarnings("unchecked") List<PipelineKey> pipelines = mock(List.class); when(runtimeService.getPipelines(provider.getKey().getProviderTypeKey())).thenReturn(pipelines); perspective.onAddNewRuntime(new AddNewRuntimeEvent(provider)); verify(newDeployWizard, times(1)).start(provider, pipelines); }
|
PopupHelper implements HasBusyIndicator { public void showInformationPopup(final String message) { showNotificationPopup(CommonConstants.INSTANCE.Information(), message); } @Inject PopupHelper(final ErrorPopup errorPopup); void showInformationPopup(final String message); void showErrorPopup(final String message); void showErrorPopup(final String message,
final String detail); void showYesNoPopup(final String title,
final String message,
final Command yesCommand,
final Command noCommand); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); ErrorCallback<Message> getPopupErrorCallback(); }
|
@Test public void testShowInformationPopup() { popupHelper.showInformationPopup(MESSAGE); verify(popupHelper, times(1)).newNotificationPopup(CommonConstants.INSTANCE.Information(), MESSAGE); verifyPopupWasShown(yesNoCancelPopup); }
|
PopupHelper implements HasBusyIndicator { public void showErrorPopup(final String message) { errorPopup.showError(message, STANDARD); } @Inject PopupHelper(final ErrorPopup errorPopup); void showInformationPopup(final String message); void showErrorPopup(final String message); void showErrorPopup(final String message,
final String detail); void showYesNoPopup(final String title,
final String message,
final Command yesCommand,
final Command noCommand); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); ErrorCallback<Message> getPopupErrorCallback(); }
|
@Test public void testShowErrorPopup() { popupHelper.showErrorPopup(MESSAGE); errorPopup.showError(MESSAGE); }
@Test public void testShowErrorPopupWithDetail() { popupHelper.showErrorPopup(MESSAGE, DETAIL); errorPopup.showError(MESSAGE, DETAIL); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.