method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testStartRuntime() { runtimeProvisioningServiceBackend.startRuntime(RUNTIME_ID); verify(runtimeProvisioningService).startRuntime(RUNTIME_ID); } |
### Question:
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); }### Answer:
@Test public void testStopRuntime() { runtimeProvisioningServiceBackend.stopRuntime(RUNTIME_ID); verify(runtimeProvisioningService).stopRuntime(RUNTIME_ID); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testRestartRuntime() { runtimeProvisioningServiceBackend.restartRuntime(RUNTIME_ID); verify(runtimeProvisioningService).restartRuntime(RUNTIME_ID); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testStopPipelineExecution() { pipelineServiceBackend.stopPipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineService, times(1)).stopPipelineExecution(PIPELINE_EXECUTION_ID); } |
### Question:
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); }### Answer:
@Test public void testDeletePipelineExecution() { pipelineServiceBackend.deletePipelineExecution(PIPELINE_EXECUTION_ID); verify(pipelineService, times(1)).deletePipelineExecution(PIPELINE_EXECUTION_ID); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testSetColumnGroup() { header.setColumnGroup("group"); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testSetTitle() { header.setTitle("title"); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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++; } } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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(); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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))); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
ProviderConverterFactoryImpl implements ProviderConverterFactory { @Override public ProviderConverter getProviderConverter() { return providerConverter; } ProviderConverterFactoryImpl(); @Inject ProviderConverterFactoryImpl(final BackendProviderHandlerRegistry handlerRegistry); @Override ProviderConfigConverter getProviderConfigConverter(final ProviderTypeKey providerTypeKey); @Override ProviderConverter getProviderConverter(); }### Answer:
@Test public void testGetProviderConverter() { assertNotNull(converterFactory.getProviderConverter()); } |
### Question:
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); }### Answer:
@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))); } |
### Question:
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); }### Answer:
@Test public void testGetProviders() { Collection<Provider> result = service.getProviders(providerType); assertEquals(providers, result); } |
### Question:
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); }### Answer:
@Test public void testGetProvidersKey() { Collection<ProviderKey> result = service.getProvidersKey(providerType); assertEquals(providerKeys, result); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@Test public void testDestroyResources() { header.destroyResources(); verify(editor).hide(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testBeforePipelineExecution() { listener.beforePipelineExecution(new BeforePipelineExecutionEvent(EXECUTION_ID, pipeline)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.RUNNING)); } |
### Question:
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); }### Answer:
@Test public void testAfterPipelineExecution() { listener.afterPipelineExecution(new AfterPipelineExecutionEvent(EXECUTION_ID, pipeline)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.FINISHED)); } |
### Question:
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(); }### Answer:
@Test public void checkGetTitleWithHasName() { hasName = Optional.of(new MockHasName("name")); assertEquals("name", header.getTitle()); }
@Test public void checkGetTitleWithoutHasName() { hasName = Optional.empty(); assertEquals("", header.getTitle()); } |
### Question:
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); }### Answer:
@Test public void testBeforeStageExecution() { listener.beforeStageExecution(new BeforeStageExecutionEvent(EXECUTION_ID, pipeline, stage)); verify(stageStatusChangeEvent, times(1)).fire(new StageStatusChangeEvent(traceKey, STAGE_NAME, PipelineStatus.RUNNING)); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@Test public void testAfterStageExecution() { listener.afterStageExecution(new AfterStageExecutionEvent(EXECUTION_ID, pipeline, stage)); verify(stageStatusChangeEvent, times(1)).fire(new StageStatusChangeEvent(traceKey, STAGE_NAME, PipelineStatus.FINISHED)); } |
### Question:
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); }### Answer:
@Test public void testOnPipelineError() { listener.onPipelineError(new OnErrorPipelineExecutionEvent(EXECUTION_ID, pipeline, stage, throwable)); verify(pipelineStatusChangeEvent, times(1)).fire(new PipelineStatusChangeEvent(traceKey, PipelineStatus.ERROR)); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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; }### Answer:
@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()))); } |
### Question:
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; }### Answer:
@Test public void testAddNewProvider() { ProviderType providerType = mockProviderType(""); perspective.onAddNewProvider(new AddNewProviderEvent(providerType)); verify(newProviderWizard, times(1)).start(providerType); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test public void testShowInformationPopup() { popupHelper.showInformationPopup(MESSAGE); verify(popupHelper, times(1)).newNotificationPopup(CommonConstants.INSTANCE.Information(), MESSAGE); verifyPopupWasShown(yesNoCancelPopup); } |
### Question:
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(); }### Answer:
@Test public void testShowErrorPopup() { popupHelper.showErrorPopup(MESSAGE); errorPopup.showError(MESSAGE); }
@Test public void testShowErrorPopupWithDetail() { popupHelper.showErrorPopup(MESSAGE, DETAIL); errorPopup.showError(MESSAGE, DETAIL); } |
### Question:
PopupHelper implements HasBusyIndicator { public void showYesNoPopup(final String title, final String message, final Command yesCommand, final Command noCommand) { YesNoCancelPopup popup = newYesNoPopup(title, message, yesCommand, noCommand); popup.setClosable(false); popup.clearScrollHeight(); popup.show(); } @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(); }### Answer:
@Test public void testShowYesNoPopup() { Command yesCommand = mock(Command.class); Command noCommand = mock(Command.class); popupHelper.showYesNoPopup(TITLE, MESSAGE, yesCommand, noCommand); verify(popupHelper, times(1)).newYesNoPopup(TITLE, MESSAGE, yesCommand, noCommand); verifyPopupWasShown(yesNoCancelPopup); } |
### Question:
PopupHelper implements HasBusyIndicator { public ErrorCallback<Message> getPopupErrorCallback() { return (message, throwable) -> { showErrorPopup(throwable.getMessage()); return false; }; } @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(); }### Answer:
@Test public void testGetPopupErrorCallback() { Message message = mock(Message.class); popupHelper.getPopupErrorCallback().error(message, new Exception(MESSAGE)); verify(popupHelper, times(1)).showErrorPopup(MESSAGE); } |
### Question:
ProviderStatusPresenter { public void setupItems(final Collection<RuntimeListItem> response) { clear(); response.forEach(item -> { final RuntimePresenter runtimePresenter = newRuntimePresenter(); runtimePresenter.setup(item); currentItems.add(runtimePresenter); view.addListItem(runtimePresenter.getView()); }); } @Inject ProviderStatusPresenter(final View view,
final ManagedInstance<RuntimePresenter> runtimePresenterInstance); @PostConstruct void init(); void setupItems(final Collection<RuntimeListItem> response); boolean removeItem(final RuntimeKey runtimeKey); boolean removeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); boolean isEmpty(); void clear(); View getView(); }### Answer:
@Test public void testSetupItems() { List<RuntimeListItem> items = mockItems(ITEMS_COUNT); presenter.setupItems(items); verify(runtimePresenterInstance, times(ITEMS_COUNT)).get(); verify(view, times(ITEMS_COUNT)).addListItem(any()); for (int i = 0; i < ITEMS_COUNT; i++) { verify(runtimePresenters.get(i), times(1)).setup(items.get(i)); verify(view, times(1)).addListItem(runtimePresenters.get(i).getView()); } } |
### Question:
ProviderStatusPresenter { public void clear() { view.clear(); clearItems(); } @Inject ProviderStatusPresenter(final View view,
final ManagedInstance<RuntimePresenter> runtimePresenterInstance); @PostConstruct void init(); void setupItems(final Collection<RuntimeListItem> response); boolean removeItem(final RuntimeKey runtimeKey); boolean removeItem(final PipelineExecutionTraceKey pipelineExecutionTraceKey); boolean isEmpty(); void clear(); View getView(); }### Answer:
@Test public void testClear() { List<RuntimeListItem> items = mockItems(ITEMS_COUNT); presenter.setupItems(items); presenter.clear(); verify(view, times(2)).clear(); runtimePresenters.forEach(runtimePresenter -> verify(runtimePresenterInstance, times(1)).destroy(runtimePresenter)); verify(runtimePresenterInstance, times(ITEMS_COUNT)).destroy(any()); } |
### Question:
ProviderStatusEmptyPresenter { public View getView() { return view; } @Inject ProviderStatusEmptyPresenter(final View view,
final Event<RefreshRuntimeEvent> refreshRuntimeEvent); @PostConstruct void init(); View getView(); void setup(final ProviderKey providerKey); void onRefresh(); }### Answer:
@Test public void testGetView() { assertEquals(view, presenter.getView()); } |
### Question:
ProviderStatusEmptyPresenter { public void onRefresh() { refreshRuntimeEvent.fire(new RefreshRuntimeEvent(providerKey)); } @Inject ProviderStatusEmptyPresenter(final View view,
final Event<RefreshRuntimeEvent> refreshRuntimeEvent); @PostConstruct void init(); View getView(); void setup(final ProviderKey providerKey); void onRefresh(); }### Answer:
@Test public void testOnRefresh() { presenter.onRefresh(); verify(refreshRuntimeEvent, times(1)).fire(new RefreshRuntimeEvent(providerKey)); } |
### Question:
RuntimePresenterHelper { public static RuntimeStatus buildRuntimeStatus(String status) { if (status == null) { return RuntimeStatus.UNKNOWN; } switch (status) { case "READY": return RuntimeStatus.READY; case "RUNNING": return RuntimeStatus.RUNNING; case "STOPPED": return RuntimeStatus.STOPPED; case "UNKNOWN": return RuntimeStatus.UNKNOWN; default: return RuntimeStatus.UNKNOWN; } } static Collection<String> buildIconStyle(final PipelineStatus status); static RuntimeStatus buildRuntimeStatus(String status); static Collection<String> buildIconStyle(final RuntimeStatus status); static State buildStageState(final PipelineStatus stageStatus); }### Answer:
@Test public void testBuildRuntimeStatus() { assertEquals(RuntimeStatus.UNKNOWN, RuntimePresenterHelper.buildRuntimeStatus(null)); assertEquals(RuntimeStatus.RUNNING, RuntimePresenterHelper.buildRuntimeStatus("RUNNING")); assertEquals(RuntimeStatus.STOPPED, RuntimePresenterHelper.buildRuntimeStatus("STOPPED")); assertEquals(RuntimeStatus.UNKNOWN, RuntimePresenterHelper.buildRuntimeStatus("UNKNOWN")); assertEquals(RuntimeStatus.UNKNOWN, RuntimePresenterHelper.buildRuntimeStatus("whatever value")); } |
### Question:
RuntimePresenterHelper { public static State buildStageState(final PipelineStatus stageStatus) { if (stageStatus == null) { return State.DONE; } switch (stageStatus) { case RUNNING: return State.EXECUTING; case ERROR: return State.ERROR; case STOPPED: return State.STOPPED; default: return State.DONE; } } static Collection<String> buildIconStyle(final PipelineStatus status); static RuntimeStatus buildRuntimeStatus(String status); static Collection<String> buildIconStyle(final RuntimeStatus status); static State buildStageState(final PipelineStatus stageStatus); }### Answer:
@Test public void testBuildStageState() { assertEquals(State.DONE, RuntimePresenterHelper.buildStageState(null)); assertEquals(State.EXECUTING, RuntimePresenterHelper.buildStageState(PipelineStatus.RUNNING)); assertEquals(State.ERROR, RuntimePresenterHelper.buildStageState(PipelineStatus.ERROR)); assertEquals(State.STOPPED, RuntimePresenterHelper.buildStageState(PipelineStatus.STOPPED)); } |
### Question:
EditableTextHeaderMetaData implements EditableHeaderMetaData { @Override public void setTitle(final String title) { titleSetter.accept(title); } 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(); }### Answer:
@Test public void checkSetTitleWithHasName() { final HasName mockHasName = new MockHasName("name"); hasName = Optional.of(mockHasName); header.setTitle("new-name"); assertEquals("new-name", mockHasName.getName().getValue()); }
@Test public void checkSetTitleWithoutHasName() { final HasName mockHasName = new MockHasName("name"); hasName = Optional.empty(); header.setTitle("new-name"); assertEquals("name", mockHasName.getName().getValue()); } |
### Question:
RuntimePresenter { @PreDestroy public void destroy() { clearPipeline(); actionItemPresenterInstance.destroy(startAction); actionItemPresenterInstance.destroy(stopAction); actionItemPresenterInstance.destroy(deleteAction); actionItemSeparatorPresenterInstance.destroy(separator); actionItemSeparatorPresenterInstance.destroy(secondarySeparator); actionItemPresenterInstance.destroy(showErrorAction); } @Inject RuntimePresenter(final View view,
final PipelinePresenter pipelinePresenter,
final ManagedInstance<StagePresenter> stagePresenterInstance,
final ManagedInstance<TransitionPresenter> transitionPresenterInstance,
final ManagedInstance<RuntimeActionItemPresenter> actionItemPresenterInstance,
final ManagedInstance<RuntimeActionItemSeparatorPresenter> actionItemSeparatorPresenterInstance,
final Caller<RuntimeService> runtimeService,
final Event<NotificationEvent> notification,
final PopupHelper popupHelper,
final TranslationService translationService); @PostConstruct void init(); @PreDestroy void destroy(); View getView(); void setup(final RuntimeListItem runtimeListItem); RuntimeListItem getItem(); void onStageStatusChange(@Observes final StageStatusChangeEvent event); void onPipelineStatusChange(@Observes final PipelineStatusChangeEvent event); void onPipelineExecutionChange(@Observes final PipelineExecutionChangeEvent event); void onRuntimeChangeEvent(@Observes final RuntimeChangeEvent event); }### Answer:
@Test public void testDestroy() { presenter.destroy(); verify(actionItemPresenterInstance, times(1)).destroy(startActionPresenter); verify(actionItemPresenterInstance, times(1)).destroy(stopActionPresenter); verify(actionItemPresenterInstance, times(1)).destroy(deleteActionPresenter); verify(actionItemSeparatorPresenterInstance, times(1)).destroy(separatorPresenter); verify(actionItemSeparatorPresenterInstance, times(1)).destroy(secondarySeparatorPresenter); } |
### Question:
RuntimePresenter { public View getView() { return view; } @Inject RuntimePresenter(final View view,
final PipelinePresenter pipelinePresenter,
final ManagedInstance<StagePresenter> stagePresenterInstance,
final ManagedInstance<TransitionPresenter> transitionPresenterInstance,
final ManagedInstance<RuntimeActionItemPresenter> actionItemPresenterInstance,
final ManagedInstance<RuntimeActionItemSeparatorPresenter> actionItemSeparatorPresenterInstance,
final Caller<RuntimeService> runtimeService,
final Event<NotificationEvent> notification,
final PopupHelper popupHelper,
final TranslationService translationService); @PostConstruct void init(); @PreDestroy void destroy(); View getView(); void setup(final RuntimeListItem runtimeListItem); RuntimeListItem getItem(); void onStageStatusChange(@Observes final StageStatusChangeEvent event); void onPipelineStatusChange(@Observes final PipelineStatusChangeEvent event); void onPipelineExecutionChange(@Observes final PipelineExecutionChangeEvent event); void onRuntimeChangeEvent(@Observes final RuntimeChangeEvent event); }### Answer:
@Test public void testGetView() { assertEquals(view, presenter.getView()); } |
### Question:
RuntimeActionItemSeparatorPresenter { public View getView() { return view; } @Inject RuntimeActionItemSeparatorPresenter(final View view); @PostConstruct void init(); View getView(); }### Answer:
@Test public void testGetView() { assertEquals(view, presenter.getView()); } |
### Question:
RuntimeActionItemPresenter { public void setup(final String label, final Command command) { view.setLabel(label); this.command = command; } @Inject RuntimeActionItemPresenter(final View view); @PostConstruct void init(); void setup(final String label,
final Command command); void setEnabled(final boolean enabled); View getView(); }### Answer:
@Test public void testSetup() { presenter.setup(LABEL, command); verify(view, times(1)).setLabel(LABEL); presenter.onActionClick(); verify(command, times(1)).execute(); } |
### Question:
RuntimeActionItemPresenter { public void setEnabled(final boolean enabled) { view.setEnabled(enabled); } @Inject RuntimeActionItemPresenter(final View view); @PostConstruct void init(); void setup(final String label,
final Command command); void setEnabled(final boolean enabled); View getView(); }### Answer:
@Test public void testSetEnabledTrue() { presenter.setEnabled(true); verify(view, times(1)).setEnabled(true); }
@Test public void testSetEnabledFalse() { presenter.setEnabled(false); verify(view, times(1)).setEnabled(false); } |
### Question:
RuntimeActionItemPresenter { public View getView() { return view; } @Inject RuntimeActionItemPresenter(final View view); @PostConstruct void init(); void setup(final String label,
final Command command); void setEnabled(final boolean enabled); View getView(); }### Answer:
@Test public void testGetView() { assertEquals(view, presenter.getView()); } |
### Question:
ProviderPresenter { public void onProviderSelected(@Observes final ProviderSelectedEvent event) { if (event.getProviderKey() != null) { load(event.getProviderKey()); } } @Inject ProviderPresenter(final View view,
final Caller<ProviderService> providerService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final ProviderStatusEmptyPresenter providerStatusEmptyPresenter,
final ProviderStatusPresenter providerStatusPresenter,
final ProviderConfigEmptyPresenter providerConfigEmptyPresenter,
final ClientProviderHandlerRegistry providerHandlerRegistry,
final Event<NotificationEvent> notification,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent,
final Event<AddNewRuntimeEvent> addNewRuntimeEvent); @PostConstruct void init(); void onProviderSelected(@Observes final ProviderSelectedEvent event); void onRefreshRuntime(@Observes final RefreshRuntimeEvent event); void refresh(); void onRemoveProvider(); void removeProvider(); void deploy(); IsElement getView(); }### Answer:
@Test public void testOnProviderSelectedWithRuntimes() { prepareRuntimesInfo(); when(runtimeItems.isEmpty()).thenReturn(false); presenter.onProviderSelected(new ProviderSelectedEvent(providerKey)); verifyUILoadedWithItems(1); verifyRuntimesInfoLoaded(1); }
@Test public void testOnProviderSelectedWithNoRuntimes() { prepareRuntimesInfo(); when(runtimeItems.isEmpty()).thenReturn(true); presenter.onProviderSelected(new ProviderSelectedEvent(providerKey)); verifyUILoadedWithNoItems(1); verifyRuntimesInfoLoaded(1); } |
### Question:
ProviderPresenter { public void onRefreshRuntime(@Observes final RefreshRuntimeEvent event) { if (event.getProviderKey() != null && event.getProviderKey().equals(provider.getKey())) { load(event.getProviderKey()); } } @Inject ProviderPresenter(final View view,
final Caller<ProviderService> providerService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final ProviderStatusEmptyPresenter providerStatusEmptyPresenter,
final ProviderStatusPresenter providerStatusPresenter,
final ProviderConfigEmptyPresenter providerConfigEmptyPresenter,
final ClientProviderHandlerRegistry providerHandlerRegistry,
final Event<NotificationEvent> notification,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent,
final Event<AddNewRuntimeEvent> addNewRuntimeEvent); @PostConstruct void init(); void onProviderSelected(@Observes final ProviderSelectedEvent event); void onRefreshRuntime(@Observes final RefreshRuntimeEvent event); void refresh(); void onRemoveProvider(); void removeProvider(); void deploy(); IsElement getView(); }### Answer:
@Test public void testOnRefreshRuntimesWithItems() { prepareRefreshWithItems(); presenter.onRefreshRuntime(new RefreshRuntimeEvent(providerKey)); verify(providerStatusPresenter, times(2)).setupItems(runtimeItems); verify(view, times(2)).setStatus(providerStatusPresenterView); verifyRuntimesInfoLoaded(2); }
@Test public void testOnRefreshRuntimesWithNoItems() { prepareRefreshWithNoItems(); presenter.onRefreshRuntime(new RefreshRuntimeEvent(providerKey)); verifyUILoadedWithNoItems(2); verifyRuntimesInfoLoaded(2); } |
### Question:
ProviderPresenter { public void refresh() { load(provider.getKey()); } @Inject ProviderPresenter(final View view,
final Caller<ProviderService> providerService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final ProviderStatusEmptyPresenter providerStatusEmptyPresenter,
final ProviderStatusPresenter providerStatusPresenter,
final ProviderConfigEmptyPresenter providerConfigEmptyPresenter,
final ClientProviderHandlerRegistry providerHandlerRegistry,
final Event<NotificationEvent> notification,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent,
final Event<AddNewRuntimeEvent> addNewRuntimeEvent); @PostConstruct void init(); void onProviderSelected(@Observes final ProviderSelectedEvent event); void onRefreshRuntime(@Observes final RefreshRuntimeEvent event); void refresh(); void onRemoveProvider(); void removeProvider(); void deploy(); IsElement getView(); }### Answer:
@Test public void testRefreshWithItems() { prepareRefreshWithItems(); presenter.refresh(); verify(providerStatusPresenter, times(2)).setupItems(runtimeItems); verify(view, times(2)).setStatus(providerStatusPresenterView); verifyRuntimesInfoLoaded(2); }
@Test public void testRefreshWithNoItems() { prepareRefreshWithNoItems(); presenter.refresh(); verifyUILoadedWithNoItems(2); verifyRuntimesInfoLoaded(2); } |
### Question:
ProviderPresenter { public void deploy() { addNewRuntimeEvent.fire(new AddNewRuntimeEvent(provider)); } @Inject ProviderPresenter(final View view,
final Caller<ProviderService> providerService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final ProviderStatusEmptyPresenter providerStatusEmptyPresenter,
final ProviderStatusPresenter providerStatusPresenter,
final ProviderConfigEmptyPresenter providerConfigEmptyPresenter,
final ClientProviderHandlerRegistry providerHandlerRegistry,
final Event<NotificationEvent> notification,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent,
final Event<AddNewRuntimeEvent> addNewRuntimeEvent); @PostConstruct void init(); void onProviderSelected(@Observes final ProviderSelectedEvent event); void onRefreshRuntime(@Observes final RefreshRuntimeEvent event); void refresh(); void onRemoveProvider(); void removeProvider(); void deploy(); IsElement getView(); }### Answer:
@Test public void testDeploy() { prepareRuntimesInfo(); presenter.onProviderSelected(new ProviderSelectedEvent(providerKey)); presenter.deploy(); verify(addNewRuntimeEvent, times(1)).fire(new AddNewRuntimeEvent(provider)); } |
### Question:
ProviderTypeEmptyPresenter { public void onAddProviderType() { addNewProviderTypeEvent.fire(new AddNewProviderTypeEvent()); } @Inject ProviderTypeEmptyPresenter(final View view,
final Event<AddNewProviderTypeEvent> addNewProviderTypeEvent); @PostConstruct void init(); View getView(); void onAddProviderType(); }### Answer:
@Test public void onAddProviderTypeTest() { presenter.onAddProviderType(); verify(addNewProviderTypeEvent, times(1)).fire(any(AddNewProviderTypeEvent.class)); } |
### Question:
ProvisioningManagementBrowserPresenter { @WorkbenchPartTitle public String getTitle() { return view.getTitle(); } @Inject ProvisioningManagementBrowserPresenter(final ProvisioningManagementBrowserPresenter.View view,
final ProviderTypeNavigationPresenter providerTypeNavigationPresenter,
final ProviderTypePresenter providerTypePresenter,
final ProviderTypeEmptyPresenter providerTypeEmptyPresenter,
final ProviderEmptyPresenter providerEmptyPresenter,
final ProviderPresenter providerPresenter,
final Caller<ProviderTypeService> providerTypeService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent); @PostConstruct void init(); @OnOpen void onOpen(); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView IsElement getView(); static final String IDENTIFIER; }### Answer:
@Test public void testGetTitle() { when(view.getTitle()).thenReturn(TITLE); assertEquals(TITLE, presenter.getTitle()); verify(view, times(1)).getTitle(); } |
### Question:
ProvisioningManagementBrowserPresenter { @WorkbenchPartView public IsElement getView() { return view; } @Inject ProvisioningManagementBrowserPresenter(final ProvisioningManagementBrowserPresenter.View view,
final ProviderTypeNavigationPresenter providerTypeNavigationPresenter,
final ProviderTypePresenter providerTypePresenter,
final ProviderTypeEmptyPresenter providerTypeEmptyPresenter,
final ProviderEmptyPresenter providerEmptyPresenter,
final ProviderPresenter providerPresenter,
final Caller<ProviderTypeService> providerTypeService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent); @PostConstruct void init(); @OnOpen void onOpen(); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView IsElement getView(); static final String IDENTIFIER; }### Answer:
@Test public void testGetView() { assertEquals(view, presenter.getView()); } |
### Question:
ProvisioningManagementBrowserPresenter { protected void onRefreshProviderTypes(@Observes final ProviderTypeListRefreshEvent event) { refreshProviderTypes(event.getProviderTypeKey()); } @Inject ProvisioningManagementBrowserPresenter(final ProvisioningManagementBrowserPresenter.View view,
final ProviderTypeNavigationPresenter providerTypeNavigationPresenter,
final ProviderTypePresenter providerTypePresenter,
final ProviderTypeEmptyPresenter providerTypeEmptyPresenter,
final ProviderEmptyPresenter providerEmptyPresenter,
final ProviderPresenter providerPresenter,
final Caller<ProviderTypeService> providerTypeService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent); @PostConstruct void init(); @OnOpen void onOpen(); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView IsElement getView(); static final String IDENTIFIER; }### Answer:
@Test public void testOnRefreshProviderTypesWithEnabledProviderTypes() { when(providerTypeService.getEnabledProviderTypes()).thenReturn(providerTypes); ProviderType selectedProviderType = providerTypes.iterator().next(); presenter.onRefreshProviderTypes(new ProviderTypeListRefreshEvent(selectedProviderType.getKey())); verify(providerTypeNavigationPresenter, times(1)).setup(selectedProviderType, providerTypes); verify(providerTypeSelectedEvent, times(1)).fire(new ProviderTypeSelectedEvent(selectedProviderType.getKey())); }
@Test public void testOnRefreshProviderTypesWithNOEnabledProviderTypes() { providerTypes.clear(); when(providerTypeService.getEnabledProviderTypes()).thenReturn(providerTypes); presenter.onRefreshProviderTypes(new ProviderTypeListRefreshEvent()); verify(view, times(1)).setEmptyView(providerTypeEmptyPresenterView); verify(providerTypeNavigationPresenter, times(1)).clear(); verify(providerTypeNavigationPresenter, times(0)).setup(any(ProviderType.class), anyCollectionOf(ProviderType.class)); } |
### Question:
EditableTextHeaderMetaData implements EditableHeaderMetaData { @Override public void destroyResources() { factory.destroyResources(); } 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(); }### Answer:
@Test public void checkFactoryResourcesAreDestroyed() { header.destroyResources(); verify(factory).destroyResources(); } |
### Question:
ProvisioningManagementBrowserPresenter { protected void onProviderSelected(@Observes final ProviderSelectedEvent event) { if (event.getProviderKey() != null) { this.view.setContent(providerPresenter.getView()); } } @Inject ProvisioningManagementBrowserPresenter(final ProvisioningManagementBrowserPresenter.View view,
final ProviderTypeNavigationPresenter providerTypeNavigationPresenter,
final ProviderTypePresenter providerTypePresenter,
final ProviderTypeEmptyPresenter providerTypeEmptyPresenter,
final ProviderEmptyPresenter providerEmptyPresenter,
final ProviderPresenter providerPresenter,
final Caller<ProviderTypeService> providerTypeService,
final Caller<ProvisioningScreensService> provisioningScreensService,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent); @PostConstruct void init(); @OnOpen void onOpen(); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView IsElement getView(); static final String IDENTIFIER; }### Answer:
@Test public void testOnProviderSelected() { presenter.onProviderSelected(new ProviderSelectedEvent(mock(ProviderKey.class))); verify(view, times(1)).setContent(providerPresenterView); } |
### Question:
BaseFormResolver implements FormResolver<T> { @Override public T newProviderConfigurationForm() { return managedInstance.get(); } BaseFormResolver(final ManagedInstance<T> managedInstance); @Override T newProviderConfigurationForm(); @Override void destroyForm(T form); }### Answer:
@Test public void testNewProviderConfigurationForm() { T result = formResolver.newProviderConfigurationForm(); assertEquals(form, result); verify(managedInstance, times(1)).get(); } |
### Question:
BaseFormResolver implements FormResolver<T> { @Override public void destroyForm(T form) { if (form != null) { managedInstance.destroy(form); } } BaseFormResolver(final ManagedInstance<T> managedInstance); @Override T newProviderConfigurationForm(); @Override void destroyForm(T form); }### Answer:
@Test public void testDestroyForm() { formResolver.destroyForm(form); verify(managedInstance, times(1)).destroy(form); }
@Test public void testDestroyNullForm() { formResolver.destroyForm(null); verify(managedInstance, never()).destroy(anyObject()); } |
### Question:
SelectPipelinePagePresenter implements WizardPage { public void setup(final Collection<PipelineKey> pipelines) { clear(); pipelines.forEach(pipeline -> { final PipelineItemPresenter presenter = newItemPresenter(); presenter.setup(pipeline); presenter.addContentChangeHandler(this::onContentChange); itemPresenters.add(presenter); view.addPipelineItem(presenter.getView()); }); itemPresenters.forEach(item -> item.addOthers(itemPresenters)); } @Inject SelectPipelinePagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent,
final ManagedInstance<PipelineItemPresenter> itemPresenterInstance); @PostConstruct void init(); void setup(final Collection<PipelineKey> pipelines); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); void clear(); @Override String getTitle(); @Override Widget asWidget(); PipelineKey getPipeline(); }### Answer:
@Test public void testSetup() { presenter.setup(pipelines); verify(view, times(1)).clear(); assertEquals(pipelines.size(), presenter.getItemPresenters().size()); verify(itemPresenterInstance, times(pipelines.size())).get(); for (int i = 0; i < presenter.getItemPresenters().size(); i++) { PipelineItemPresenter itemPresenter = presenter.getItemPresenters().get(i); verify(itemPresenter, times(1)).setup(pipelines.get(i)); verify(itemPresenter, times(1)).addContentChangeHandler(any(ContentChangeHandler.class)); verify(view, times(1)).addPipelineItem(itemPresenter.getView()); verify(itemPresenter, times(1)).addOthers(presenter.getItemPresenters()); } } |
### Question:
PipelineItemPresenter extends AbstractHasContentChangeHandlers { public void setup(final PipelineKey pipeline) { this.pipeline = pipeline; view.setPipelineName(pipeline.getId()); } @Inject PipelineItemPresenter(final View view); @PostConstruct void init(); void setup(final PipelineKey pipeline); PipelineKey getPipeline(); void addOthers(final Collection<PipelineItemPresenter> items); boolean isSelected(); IsElement getView(); }### Answer:
@Test public void testSetup() { presenter.setup(PIPELINE1_KEY); verify(view, times(1)).setPipelineName(PIPELINE1); } |
### Question:
PipelineItemPresenter extends AbstractHasContentChangeHandlers { public PipelineKey getPipeline() { return pipeline; } @Inject PipelineItemPresenter(final View view); @PostConstruct void init(); void setup(final PipelineKey pipeline); PipelineKey getPipeline(); void addOthers(final Collection<PipelineItemPresenter> items); boolean isSelected(); IsElement getView(); }### Answer:
@Test public void testGetPipeline() { presenter.setup(PIPELINE1_KEY); assertEquals(PIPELINE1_KEY, presenter.getPipeline()); } |
### Question:
PipelineItemPresenter extends AbstractHasContentChangeHandlers { public boolean isSelected() { return view.isSelected(); } @Inject PipelineItemPresenter(final View view); @PostConstruct void init(); void setup(final PipelineKey pipeline); PipelineKey getPipeline(); void addOthers(final Collection<PipelineItemPresenter> items); boolean isSelected(); IsElement getView(); }### Answer:
@Test public void testIsSelected() { when(view.isSelected()).thenReturn(true); assertTrue(presenter.isSelected()); when(view.isSelected()).thenReturn(false); assertFalse(presenter.isSelected()); } |
### Question:
PipelineParamsPagePresenter implements WizardPage { public void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm) { this.pipelineParamsForm = pipelineParamsForm; this.view.setForm(pipelineParamsForm.getView()); pipelineParamsForm.addContentChangeHandler(this::onContentChanged); } @Inject PipelineParamsPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); }### Answer:
@Test public void testSetPipelineParamsForm() { IsElement formView = mock(IsElement.class); when(paramsForm.getView()).thenReturn(formView); presenter.setPipelineParamsForm(paramsForm); verify(view, times(1)).setForm(formView); verify(paramsForm, times(1)).addContentChangeHandler(any(ContentChangeHandler.class)); } |
### Question:
EditableTextHeaderMetaData implements EditableHeaderMetaData { @Override public void edit(final GridBodyCellEditContext context) { factory.attachDomElement(context, (e) -> e.setValue(getTitle()), (e) -> e.setFocus(true)); } 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(); }### Answer:
@Test @SuppressWarnings("unchecked") public void checkEdit() { final GridBodyCellEditContext context = mock(GridBodyCellEditContext.class); header.edit(context); verify(factory).attachDomElement(eq(context), any(Consumer.class), any(Consumer.class)); } |
### Question:
PipelineParamsPagePresenter implements WizardPage { @Override public void prepareView() { pipelineParamsForm.prepareView(); } @Inject PipelineParamsPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); }### Answer:
@Test public void testPrepareView() { presenter.setPipelineParamsForm(paramsForm); presenter.prepareView(); verify(paramsForm, times(1)).prepareView(); } |
### Question:
PipelineParamsPagePresenter implements WizardPage { @Override public void isComplete(final Callback<Boolean> callback) { pipelineParamsForm.isComplete(callback); } @Inject PipelineParamsPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); }### Answer:
@Test public void testIsComplete() { presenter.setPipelineParamsForm(paramsForm); Callback callback = mock(Callback.class); presenter.isComplete(callback); verify(paramsForm, times(1)).isComplete(callback); } |
### Question:
PipelineParamsPagePresenter implements WizardPage { @Override public String getTitle() { return pipelineParamsForm.getWizardTitle(); } @Inject PipelineParamsPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); }### Answer:
@Test public void testGetTitle() { presenter.setPipelineParamsForm(paramsForm); when(paramsForm.getWizardTitle()).thenReturn(TITLE); assertEquals(TITLE, paramsForm.getWizardTitle()); } |
### Question:
PipelineParamsPagePresenter implements WizardPage { protected void onContentChanged() { wizardPageStatusChangeEvent.fire(new WizardPageStatusChangeEvent(PipelineParamsPagePresenter.this)); } @Inject PipelineParamsPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setPipelineParamsForm(final PipelineParamsForm pipelineParamsForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); }### Answer:
@Test public void testOnContentChanged() { presenter.onContentChanged(); verify(wizardPageStatusChangeEvent, times(1)).fire(any(WizardPageStatusChangeEvent.class)); } |
### Question:
ProviderConfigEmptyPresenter implements ProviderConfigurationForm { public void isValid(final Callback<Boolean> callback) { callback.callback(false); } @Inject ProviderConfigEmptyPresenter(final View view); @PostConstruct void init(); View getView(); @Override void addContentChangeHandler(final ContentChangeHandler contentChangeHandler); @Override ProviderConfiguration buildProviderConfiguration(); @Override void clear(); void isValid(final Callback<Boolean> callback); @Override String getWizardTitle(); @Override void disable(); @Override void load(final Provider provider); }### Answer:
@Test public void testIsValid() { presenter.isValid(Assert::assertFalse); } |
### Question:
ProviderConfigurationPagePresenter implements WizardPage { public void setProviderConfigurationForm(final ProviderConfigurationForm providerConfigurationForm) { this.providerConfigurationForm = providerConfigurationForm; this.view.setForm(providerConfigurationForm.getView()); providerConfigurationForm.addContentChangeHandler(this::onContentChanged); } @Inject ProviderConfigurationPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setProviderConfigurationForm(final ProviderConfigurationForm providerConfigurationForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); void clear(); ProviderConfiguration buildProviderConfiguration(); }### Answer:
@Test public void testSetProviderConfigurationForm() { presenter.setProviderConfigurationForm(configurationForm); verify(view, times(1)).setForm(configurationFormView); verify(configurationForm, times(1)).addContentChangeHandler(any(ContentChangeHandler.class)); } |
### Question:
ProviderConfigurationPagePresenter implements WizardPage { public void clear() { if (providerConfigurationForm != null) { providerConfigurationForm.clear(); } } @Inject ProviderConfigurationPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setProviderConfigurationForm(final ProviderConfigurationForm providerConfigurationForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); void clear(); ProviderConfiguration buildProviderConfiguration(); }### Answer:
@Test public void testClear() { presenter.setProviderConfigurationForm(configurationForm); presenter.clear(); verify(configurationForm, times(1)).clear(); } |
### Question:
ProviderConfigurationPagePresenter implements WizardPage { public ProviderConfiguration buildProviderConfiguration() { return providerConfigurationForm.buildProviderConfiguration(); } @Inject ProviderConfigurationPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setProviderConfigurationForm(final ProviderConfigurationForm providerConfigurationForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); void clear(); ProviderConfiguration buildProviderConfiguration(); }### Answer:
@Test public void testBuildProviderConfiguration() { presenter.setProviderConfigurationForm(configurationForm); presenter.buildProviderConfiguration(); verify(configurationForm, times(1)).buildProviderConfiguration(); } |
### Question:
ProviderConfigurationPagePresenter implements WizardPage { protected void onContentChanged() { wizardPageStatusChangeEvent.fire(new WizardPageStatusChangeEvent(ProviderConfigurationPagePresenter.this)); } @Inject ProviderConfigurationPagePresenter(final View view,
final Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @PostConstruct void init(); void setProviderConfigurationForm(final ProviderConfigurationForm providerConfigurationForm); @Override void initialise(); @Override void prepareView(); @Override void isComplete(final Callback<Boolean> callback); @Override String getTitle(); @Override Widget asWidget(); void clear(); ProviderConfiguration buildProviderConfiguration(); }### Answer:
@Test public void testOnContentChanged() { presenter.onContentChanged(); verify(wizardPageStatusChangeEvent, times(1)).fire(any(WizardPageStatusChangeEvent.class)); } |
### Question:
NewProviderWizard extends AbstractMultiPageWizard { public void start(final ProviderType providerType) { this.providerType = providerType; this.providerConfigurationForm = getProviderConfigurationForm(providerType.getKey()); if (providerConfigurationForm != null) { providerConfigurationPage.setProviderConfigurationForm(providerConfigurationForm); clear(); super.start(); } else { popupHelper.showErrorPopup(translationService.format( NewProviderWizard_ProviderNotProperlyConfiguredInSystemErrorMessage, (providerType != null ? providerType.getName() : null))); } } @Inject NewProviderWizard(final ProviderConfigurationPagePresenter providerConfigurationPage,
final ClientProviderHandlerRegistry handlerRegistry,
final PopupHelper popupHelper,
final TranslationService translationService,
final Caller<ProviderService> providerService,
final Event<NotificationEvent> notification,
final Event<ProviderTypeSelectedEvent> providerTypeSelectedEvent); @PostConstruct void init(); void start(final ProviderType providerType); @Override String getTitle(); @Override int getPreferredHeight(); @Override int getPreferredWidth(); @Override void complete(); }### Answer:
@Test public void testStartProviderConfigured() { wizard.start(providerType); verify(handlerRegistry, times(2)).getProviderHandler(providerType.getKey()); verify(providerHandler, times(2)).getFormResolver(); verify(formResolver, times(1)).newProviderConfigurationForm(); verify(configurationPage, times(1)).setProviderConfigurationForm(configurationForm); }
@Test public void testStartProviderNotConfigured() { when(handlerRegistry.isProviderInstalled(providerType.getKey())).thenReturn(false); wizard.start(providerType); verify(handlerRegistry, never()).getProviderHandler(providerType.getKey()); verify(providerHandler, never()).getFormResolver(); verify(formResolver, never()).newProviderConfigurationForm(); verify(configurationPage, never()).setProviderConfigurationForm(configurationForm); wizard.start(); verify(popupHelper, times(1)).showErrorPopup(ERROR_MESSAGE); } |
### Question:
EditableTextHeaderMetaData implements EditableHeaderMetaData { @Override public GridCellEditAction getSupportedEditAction() { return GridCellEditAction.DOUBLE_CLICK; } 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(); }### Answer:
@Test public void testSupportedEditAction() { assertThat(header.getSupportedEditAction()).isEqualTo(GridCellEditAction.DOUBLE_CLICK); } |
### Question:
SourceConfigurationParamsPresenter extends AbstractHasContentChangeHandlers implements PipelineParamsForm { @Override public void initialise() { setup(); } @Inject SourceConfigurationParamsPresenter(final View view,
final Caller<SourceService> sourceService); @PostConstruct void init(); @Override IsElement getView(); @Override String getWizardTitle(); @Override void isComplete(final Callback<Boolean> callback); @Override void initialise(); @Override void prepareView(); @Override Map<String, String> buildParams(); @Override void clear(); void disable(); static final String REPO_NAME; static final String BRANCH; static final String MODULE_DIR; }### Answer:
@Test public void testInitialize() { when(sourceService.getOrganizationUnits()).thenReturn(ous); presenter.initialise(); ous.forEach(ou -> verify(view, times(1)).addOrganizationUnit(ou)); verify(view, times(1)).clearOrganizationUnits(); verify(view, times(1)).clearRepositories(); verify(view, times(1)).clearBranches(); verify(view, times(1)).clearModules(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.