method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { QName normaliseBuiltInTypeTypeRef(final QName typeRef) { return itemDefinitionUtils.normaliseTypeRef(typeRef); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testNormaliseBuiltInTypeTypeRef() { final QName typeRef = mock(QName.class); final QName expectedTypeRef = mock(QName.class); doReturn(expectedTypeRef).when(itemDefinitionUtils).normaliseTypeRef(typeRef); final QName actualTypeRef = picker.normaliseBuiltInTypeTypeRef(typeRef); assertEquals(expectedTypeRef, actualTypeRef); } |
### Question:
ExpressionLanguagePropertyConverter { public static String dmnFromWB(final ExpressionLanguage language) { if (language == null) { return null; } else if (StringUtils.isEmpty(language.getValue())) { return null; } else { return language.getValue(); } } static ExpressionLanguage wbFromDMN(final String language); static String dmnFromWB(final ExpressionLanguage language); }### Answer:
@Test public void testDMNFromWBWithNull() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(null)); }
@Test public void testDMNFromWBWithNullValue() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage(null))); }
@Test public void testDMNFromWBWithEmptyValue() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage())); }
@Test public void testDMNFromWBWithNonNullValue() { assertEquals(EXPRESSION_LANGUAGE, ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage(EXPRESSION_LANGUAGE))); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testShow() { editor.bind(bound, 0, 0); editor.show(); verify(view).show(Optional.empty()); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void hide() { binding.ifPresent(b -> view.hide()); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testHide() { editor.bind(bound, 0, 0); editor.hide(); verify(view).hide(); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void bind(final HasValueAndTypeRef bound, final int uiRowIndex, final int uiColumnIndex) { binding = Optional.ofNullable(bound); refresh(); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testBind() { editor.bind(bound, 0, 0); verify(view).setDMNModel(eq(decision)); verify(view).initValue(eq(NAME)); verify(view).initSelectedTypeRef(eq(typeRef)); editor.show(); verify(view).show(Optional.empty()); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void setTypeRef(final QName typeRef) { binding.ifPresent(b -> b.setTypeRef(typeRef)); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testSetTypeRef() { editor.bind(bound, 0, 0); editor.setTypeRef(typeRef); verify(bound).setTypeRef(eq(typeRef)); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallback_WhenNotBound() { final Consumer callback = mock(Consumer.class); editor.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public String getValueLabel() { return binding.orElseThrow(() -> new IllegalStateException(BINDING_EXCEPTION)).getValueLabel(); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testGetValueLabel_WhenNotBound() { final Throwable thrown = catchThrowable(() -> editor.getValueLabel()); assertThat(thrown).isInstanceOf(IllegalStateException.class) .hasMessageContaining(BINDING_EXCEPTION); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public String normaliseValue(final String value) { return binding.orElseThrow(() -> new IllegalStateException(BINDING_EXCEPTION)).normaliseValue(value); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testNormaliseValue_WhenNotBound() { final Throwable thrown = catchThrowable(() -> editor.normaliseValue(NAME)); assertThat(thrown).isInstanceOf(IllegalStateException.class) .hasMessageContaining(BINDING_EXCEPTION); } |
### Question:
DataTypeNameValidator { public boolean isValid(final DataType dataType) { if (isBlank(dataType)) { flashMessageEvent.fire(blankErrorMessage.getFlashMessage(dataType)); return false; } if (isNotUnique(dataType)) { flashMessageEvent.fire(notUniqueErrorMessage.getFlashMessage(dataType)); return false; } if (isDefault(dataType)) { flashMessageEvent.fire(nameIsDefaultTypeMessage.getFlashMessage(dataType)); return false; } return true; } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsValid() { final DataType dataType = mock(DataType.class); doReturn(false).when(validator).isBlank(dataType); doReturn(false).when(validator).isNotUnique(dataType); doReturn(false).when(validator).isDefault(dataType); final boolean isValid = validator.isValid(dataType); verify(flashMessageEvent, never()).fire(any()); verify(flashMessageEvent, never()).fire(any()); assertTrue(isValid); } |
### Question:
DataTypeNameValidator { boolean isBlank(final DataType dataType) { return isEmpty(dataType.getName()); } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsNotBlankWhenNameIsBlank() { final DataType dataType = makeDataType("uuid", ""); assertTrue(validator.isBlank(dataType)); }
@Test public void testIsNotBlankWhenNameIsNull() { final DataType dataType = makeDataType("uuid", null); assertTrue(validator.isBlank(dataType)); }
@Test public void testIsNotBlankWhenNameIsNotBlank() { final DataType dataType = makeDataType("uuid", "tCity"); assertFalse(validator.isBlank(dataType)); } |
### Question:
DataTypeNameValidator { boolean isDefault(final DataType dataType) { return BuiltInTypeUtils.isBuiltInType(dataType.getName()); } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsDefaultWhenItReturnsTrue() { final DataType dataType = mock(DataType.class); when(dataType.getName()).thenReturn("string"); assertTrue(validator.isDefault(dataType)); }
@Test public void testIsDefaultWhenItReturnsFalse() { final DataType dataType = mock(DataType.class); when(dataType.getName()).thenReturn("tCity"); assertFalse(validator.isDefault(dataType)); } |
### Question:
DataTypeNameValidator { public List<DataType> siblings(final DataType dataType) { final Optional<DataType> parent = Optional.ofNullable(dataTypeStore.get(dataType.getParentUUID())); if (parent.isPresent()) { return parent.get().getSubDataTypes(); } else { return dataTypeStore.getTopLevelDataTypes(); } } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testSiblingsWhenDataTypeDoesNotHaveParent() { final DataType dataType = mock(DataType.class); final List<DataType> expectedSiblings = Collections.singletonList(mock(DataType.class)); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(expectedSiblings); final List<DataType> actualSiblings = validator.siblings(dataType); assertEquals(expectedSiblings, actualSiblings); }
@Test public void testSiblingsWhenDataTypeHasParent() { final DataType dataType = mock(DataType.class); final DataType parent = mock(DataType.class); final String parentUUID = "parentUUID"; final List<DataType> expectedSiblings = Collections.singletonList(mock(DataType.class)); when(dataType.getParentUUID()).thenReturn(parentUUID); when(parent.getSubDataTypes()).thenReturn(expectedSiblings); when(dataTypeStore.get(parentUUID)).thenReturn(parent); final List<DataType> actualSiblings = validator.siblings(dataType); assertEquals(expectedSiblings, actualSiblings); } |
### Question:
ItemDefinitionStore { public ItemDefinition get(final String uuid) { return itemDefinitions.get(uuid); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testGetWhenItReturnsNull() { assertNull(store.get("456")); }
@Test public void testGetWhenItDoesNotReturnNull() { assertNotNull(store.get(uuid)); assertEquals(itemDefinition, store.get(uuid)); } |
### Question:
ItemDefinitionStore { public void index(final String uuid, final ItemDefinition itemDefinition) { itemDefinitions.put(uuid, itemDefinition); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testIndex() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final String uuid = "789"; store.index(uuid, itemDefinition); assertEquals(itemDefinition, store.get(uuid)); } |
### Question:
ItemDefinitionStore { public void clear() { itemDefinitions.clear(); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testClear() { store.clear(); assertEquals(0, store.size()); } |
### Question:
ItemDefinitionStore { public void unIndex(final String uuid) { itemDefinitions.remove(uuid); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testUnIndex() { store.unIndex(uuid); assertNull(store.get(uuid)); } |
### Question:
ItemDefinitionUpdateHandler { Name makeName(final DataType dataType) { return new Name(dataType.getName()); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeName() { final DataType dataType = mock(DataType.class); final String expectedName = "name"; when(dataType.getName()).thenReturn(expectedName); final Name name = handler.makeName(dataType); assertEquals(expectedName, name.getValue()); } |
### Question:
ItemDefinitionUpdateHandler { QName makeQName(final DataType dataType) { return normaliseTypeRef(makeQName(dataType.getType())); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeQNameWhenDataTypeIsDefault() { final DataType dataType = mock(DataType.class); final String expectedName = "string"; when(dataType.getType()).thenReturn(expectedName); final QName name = handler.makeQName(dataType); final String actualName = name.getLocalPart(); assertEquals(expectedName, actualName); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); }
@Test public void testMakeQNameWhenDataTypeIsNotDefault() { final DataType dataType = mock(DataType.class); final String expectedName = "tAddress"; when(dataType.getType()).thenReturn(expectedName); final QName name = handler.makeQName(dataType); final String actual = name.toString(); final String expected = "tAddress"; assertEquals(expected, actual); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); }
@Test public void testMakeQNameWithItemDefinition() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final Name itemDefinitionName = mock(Name.class); final String expectedName = "tAddress"; when(itemDefinitionName.getValue()).thenReturn(expectedName); when(itemDefinition.getName()).thenReturn(itemDefinitionName); final QName name = handler.makeQName(itemDefinition); final String actual = name.toString(); final String expected = "tAddress"; assertEquals(expected, actual); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); } |
### Question:
ItemDefinitionUpdateHandler { UnaryTests makeAllowedValues(final DataType dataType, final ItemDefinition itemDefinition) { final String constraint = dataType.getConstraint(); if (isEmpty(constraint)) { return null; } if (!Objects.equals(constraint, getText(itemDefinition))) { return new UnaryTests(new Id(), new Description(), new Text(constraint), null, dataType.getConstraintType()); } return itemDefinition.getAllowedValues(); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeAllowedValuesWhenDataTypeConstraintIsBlank() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(dataType.getConstraint()).thenReturn(""); final UnaryTests actualAllowedValues = handler.makeAllowedValues(dataType, itemDefinition); assertNull(actualAllowedValues); }
@Test public void testMakeAllowedValuesWhenDataTypeConstraintIsNull() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(dataType.getConstraint()).thenReturn(null); when(dataType.getConstraintType()).thenReturn(null); final UnaryTests actualAllowedValues = handler.makeAllowedValues(dataType, itemDefinition); assertNull(actualAllowedValues); } |
### Question:
ItemDefinitionDestroyHandler { public void destroy(final DataType dataType, final boolean notifyPropertiesPanel) { final ItemDefinition itemDefinition = findItemDefinition(dataType); final String destroyedItemDefinition = itemDefinition.getName().getValue(); final Optional<ItemDefinition> itemDefinitionParent = findItemDefinitionParent(dataType); itemDefinitionParent.ifPresent(parent -> { parent.getItemComponent().remove(itemDefinition); }); itemDefinitions().remove(itemDefinition); itemDefinitionStore.unIndex(dataType.getUUID()); if (notifyPropertiesPanel) { notifyPropertiesPanel(destroyedItemDefinition); } } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testDestroy() { final String uuid = "uuid"; final String oldItemDefinitionName = "oldItemDefinitionName"; final DataType dataType = mock(DataType.class); final Name name = mock(Name.class); final ItemDefinition itemDefinition = makeItemDefinition(); final ItemDefinition itemDefinitionParent = makeItemDefinition(itemDefinition); final List<ItemDefinition> itemDefinitions = new ArrayList<ItemDefinition>() {{ add(itemDefinition); }}; when(name.getValue()).thenReturn(oldItemDefinitionName); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(dataType.getUUID()).thenReturn(uuid); doReturn(Optional.of(itemDefinitionParent)).when(handler).findItemDefinitionParent(dataType); doReturn(name).when(itemDefinition).getName(); doReturn(itemDefinitions).when(handler).itemDefinitions(); doNothing().when(handler).notifyPropertiesPanel(anyString()); handler.destroy(dataType, true); assertEquals(emptyList(), itemDefinitionParent.getItemComponent()); assertEquals(emptyList(), itemDefinitions); verify(handler).notifyPropertiesPanel(oldItemDefinitionName); } |
### Question:
ItemDefinitionDestroyHandler { void notifyPropertiesPanel(final String destroyedItemDefinition) { panelNotifier .withOldLocalPart(destroyedItemDefinition) .withNewQName(new QName()) .notifyPanel(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testNotifyPropertiesPanel() { final String destroyedItemDefinition = "destroyedItemDefinition"; when(panelNotifier.withOldLocalPart(destroyedItemDefinition)).thenReturn(panelNotifier); when(panelNotifier.withNewQName(eq(new QName()))).thenReturn(panelNotifier); handler.notifyPropertiesPanel(destroyedItemDefinition); verify(panelNotifier).notifyPanel(); } |
### Question:
ItemDefinitionDestroyHandler { Optional<ItemDefinition> findItemDefinitionParent(final DataType dataType) { final Optional<ItemDefinition> itemDefinitionParent = Optional.ofNullable(itemDefinitionStore.get(dataType.getParentUUID())); if (itemDefinitionParent.isPresent()) { final ItemDefinition parent = itemDefinitionParent.get(); if (parent.getTypeRef() == null) { return Optional.of(parent); } else { for (final ItemDefinition itemDefinition : itemDefinitions()) { if (Objects.equals(itemDefinition.getName().getValue(), parent.getTypeRef().getLocalPart())) { return Optional.of(itemDefinition); } } } } return Optional.empty(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testFindItemDefinitionParentWhenParentDoesNotExist() { final DataType dataType = mock(DataType.class); final String parentUUID = "parentUUID"; when(dataType.getParentUUID()).thenReturn(parentUUID); when(itemDefinitionStore.get(parentUUID)).thenReturn(null); final Optional<ItemDefinition> expectedParent = Optional.empty(); final Optional<ItemDefinition> actualParent = handler.findItemDefinitionParent(dataType); assertEquals(expectedParent, actualParent); }
@Test public void testFindItemDefinitionParentWhenParentDoesNotHaveTypeRef() { final DataType dataType = mock(DataType.class); final ItemDefinition parent = makeItemDefinition(); final String parentUUID = "parentUUID"; when(parent.getTypeRef()).thenReturn(null); when(dataType.getParentUUID()).thenReturn(parentUUID); when(itemDefinitionStore.get(parentUUID)).thenReturn(parent); final Optional<ItemDefinition> expectedParent = Optional.of(parent); final Optional<ItemDefinition> actualParent = handler.findItemDefinitionParent(dataType); assertEquals(expectedParent, actualParent); } |
### Question:
ItemDefinitionDestroyHandler { List<ItemDefinition> itemDefinitions() { final Optional<Definitions> definitions = Optional.ofNullable(dmnGraphUtils.getModelDefinitions()); if (definitions.isPresent()) { return definitions.get().getItemDefinition(); } return new ArrayList<>(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testItemDefinitions() { final Definitions definitions = mock(Definitions.class); final ItemDefinition itemDefinition = makeItemDefinition(); final List<ItemDefinition> expectedItemDefinitions = singletonList(itemDefinition); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getItemDefinition()).thenReturn(expectedItemDefinitions); final List<ItemDefinition> actualItemDefinitions = handler.itemDefinitions(); assertEquals(expectedItemDefinitions, actualItemDefinitions); }
@Test public void testItemDefinitionsWhenDefinitionsIsNull() { final List<ItemDefinition> expectedItemDefinitions = emptyList(); when(dmnGraphUtils.getModelDefinitions()).thenReturn(null); final List<ItemDefinition> actualItemDefinitions = handler.itemDefinitions(); assertEquals(expectedItemDefinitions, actualItemDefinitions); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { public List<DataType> append(final DataType dataType, final ItemDefinition itemDefinition) { final DataType named; if (Strings.isNullOrEmpty(dataType.getName())) { named = withNoName(dataType); } else { named = dataType; } final DataType updateDataType = updateDataTypeProperties(named, TOP_LEVEL_PARENT_UUID, itemDefinition); return recordEngine.update(updateDataType); } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testAppend() { final DataType dataType = mock(DataType.class); final DataType dataTypeWithoutName = mock(DataType.class); final DataType updatedDataType = mock(DataType.class); final DataTypeManager withDataType = mock(DataTypeManager.class); final DataTypeManager withNoName = mock(DataTypeManager.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeManager.withDataType(dataType)).thenReturn(withDataType); when(withDataType.withNoName()).thenReturn(withNoName); when(withNoName.get()).thenReturn(dataTypeWithoutName); when(recordEngine.update(updatedDataType)).thenReturn(expectedAffectedDataTypes); doReturn(updatedDataType).when(handler).updateDataTypeProperties(dataTypeWithoutName, TOP_LEVEL_PARENT_UUID, itemDefinition); final List<DataType> actualAffectedDataTypes = handler.append(dataType, itemDefinition); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { public List<DataType> insertSibling(final DataType dataType, final DataType reference, final CreationType creationType, final ItemDefinition itemDefinition) { final Optional<DataType> parentOptional = lookupAbsoluteParent(reference); if (parentOptional.isPresent()) { final DataType parent = parentOptional.get(); final List<DataType> siblings = parent.getSubDataTypes(); final DataType updatedDataType = updateDataTypeProperties(dataType, parent.getUUID(), itemDefinition); final DataType parentReference = findParentReference(reference, siblings); siblings.add(siblings.indexOf(parentReference) + creationType.getIndexIncrement(), updatedDataType); recordEngine.doUpdate(dataType, itemDefinition); return recordEngine.update(parent); } else { final DataType updatedDataType = updateDataTypeProperties(dataType, reference.getParentUUID(), itemDefinition); recordEngine.doUpdate(updatedDataType, itemDefinition); return new ArrayList<>(); } } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testInsertNotNested() { final DataType dataType = mock(DataType.class); final DataType reference = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final CreationType creationType = ABOVE; doReturn(expectedAffectedDataTypes).when(handler).insertSibling(dataType, reference, creationType, itemDefinition); final List<DataType> actualAffectedDataTypes = handler.insertSibling(dataType, reference, creationType, itemDefinition); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
DataTypeHandler { public void init(final ItemDefinitionRecordEngine recordEngine) { this.recordEngine = recordEngine; } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testInit() { final ItemDefinitionRecordEngine expectedRecordEngine = mock(ItemDefinitionRecordEngine.class); handler.init(expectedRecordEngine); final ItemDefinitionRecordEngine actualRecordEngine = handler.getRecordEngine(); assertEquals(expectedRecordEngine, actualRecordEngine); } |
### Question:
DMNPathsHelperImpl implements DMNPathsHelper { @Override public List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject) { if (workspaceProject != null) { return getPathsByWorkspaceProject(pmmlQueryTerms(workspaceProject.getRootPath().toURI())); } else { return getStandalonePaths(pmmlDocumentFilter()); } } DMNPathsHelperImpl(); @Inject DMNPathsHelperImpl(final RefactoringQueryService refactoringQueryService,
final DMNImportTypesHelper importTypesHelper,
final @Named("ioStrategy") IOService ioService); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override String getRelativeURI(final Path dmnModelPath,
final Path includedModelPath); }### Answer:
@Test public void testGetPMMLDocumentsPathsWhenWorkspaceProjectIsNull() { doTestGetPathsWhenWorkspaceProjectIsNull(workspaceProject1 -> pathsHelper.getPMMLModelsPaths(null)); }
@Test public void testGetPMMLDocumentsPathsWhenWorkspaceProjectIsNotNull() { doTestGetPathsWhenWorkspaceProjectIsNotNull(workspaceProject -> pathsHelper.getPMMLModelsPaths(workspaceProject)); } |
### Question:
DataTypeHandler { List<DataType> getSubDataTypesByType(final String type) { return new DataTypeQuery().where(dataType -> Objects.equals(dataType.getType(), type)).collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testGetSubDataTypesByType() { final String type = "tCity"; final DataType dataType0 = makeDataType("tPerson", "Structure"); final DataType dataType1 = makeDataType("tCity", "Structure"); final DataType dataType2 = makeDataType("city1", "tCity"); final DataType dataType3 = makeDataType("city2", "tCity"); final DataType dataType4 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4)); final List<DataType> expectedDataTypes = asList(dataType2, dataType3); final List<DataType> actualDataTypes = handler.getSubDataTypesByType(type); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeHandler { List<DataType> forEachSubDataTypesByType(final String type, final Consumer<DataType> consumer) { return new DataTypeQuery().where(dataType -> Objects.equals(dataType.getType(), type)).apply(consumer).collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testForEachSubDataTypesByType() { final String type = "tCity"; final DataType dataType0 = makeDataType("tPerson", "Structure"); final DataType dataType1 = makeDataType("tCity", "Structure"); final DataType dataType2 = makeDataType("city1", "tCity"); final DataType dataType3 = makeDataType("city2", "tCity"); final DataType dataType4 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4)); final List<DataType> actualDataTypes = new ArrayList<>(); final List<DataType> expectedDataTypes = asList(dataType2, dataType3); final List<DataType> forEachSubDataTypesByType = handler.forEachSubDataTypesByType(type, actualDataTypes::add); assertEquals(expectedDataTypes, actualDataTypes); assertEquals(expectedDataTypes, forEachSubDataTypesByType); } |
### Question:
DataTypeHandler { List<DataType> forEachSubDataTypesByTypeOrName(final String typeOrName, final Consumer<DataType> consumer) { return new DataTypeQuery() .where(dataType -> Objects.equals(dataType.getType(), typeOrName) || Objects.equals(dataType.getName(), typeOrName)) .apply(consumer) .collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testForEachSubDataTypesByTypeOrName() { final String type = "tCompany"; final DataType dataType0 = makeDataType("RedHat", "tCompany"); final DataType dataType1 = makeDataType("tPerson", "Structure"); final DataType dataType2 = makeDataType("tCity", "Structure"); final DataType dataType3 = makeDataType("city1", "tCity"); final DataType dataType4 = makeDataType("city2", "tCity"); final DataType dataType5 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4, dataType5)); final List<DataType> actualDataTypes = new ArrayList<>(); final List<DataType> expectedDataTypes = asList(dataType0, dataType5); final List<DataType> forEachSubDataTypesByType = handler.forEachSubDataTypesByTypeOrName(type, actualDataTypes::add); assertEquals(expectedDataTypes, actualDataTypes); assertEquals(expectedDataTypes, forEachSubDataTypesByType); } |
### Question:
DataTypeHandler { void refreshSubDataTypes(final DataType dataType) { final String type = dataTypeManager.withDataType(dataType).getTypeName(); refreshSubDataTypes(dataType, type); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testRefreshSubDataTypes() { final DataTypeManager dataTypeManagerWithDataType = mock(DataTypeManager.class); final DataType dataType = makeDataType(); final String type = "type"; doNothing().when(handler).refreshSubDataTypes(any(), anyString()); when(dataTypeManager.withDataType(dataType)).thenReturn(dataTypeManagerWithDataType); when(dataTypeManagerWithDataType.getTypeName()).thenReturn(type); handler.refreshSubDataTypes(dataType); verify(handler).refreshSubDataTypes(dataType, type); }
@Test public void testRefreshSubDataTypesWithNewType() { final DataType dataType = makeDataType(); final String newType = "newType"; when(dataTypeManager.from(any(DataType.class))).thenReturn(dataTypeManager); when(dataTypeManager.withRefreshedSubDataTypes(anyString())).thenReturn(dataTypeManager); handler.refreshSubDataTypes(dataType, newType); final InOrder inOrder = Mockito.inOrder(dataTypeManager); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withRefreshedSubDataTypes(newType); } |
### Question:
DataTypeHandler { DataType parent(final DataType dataType) { return dataTypeStore.get(dataType.getParentUUID()); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testParent() { final DataType dataType = makeDataType(); final DataType expectedParent = makeDataType(); final String parentUUID = "parentUUID"; when(dataType.getParentUUID()).thenReturn(parentUUID); when(dataTypeStore.get(parentUUID)).thenReturn(expectedParent); final DataType actualParent = handler.parent(dataType); assertEquals(expectedParent, actualParent); } |
### Question:
DataTypeHandler { boolean isStructure(final DataType dataType) { return Objects.equals(dataType.getType(), dataTypeManager.structure()); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testIsStructureWhenItReturnsTrue() { final DataType dataType = mock(DataType.class); final String structure = "Structure"; when(dataTypeManager.structure()).thenReturn(structure); when(dataType.getType()).thenReturn(structure); assertTrue(handler.isStructure(dataType)); }
@Test public void testIsStructureWhenItReturnsFalse() { final DataType dataType = mock(DataType.class); when(dataTypeManager.structure()).thenReturn("Structure"); when(dataType.getType()).thenReturn("tCity"); assertFalse(handler.isStructure(dataType)); } |
### Question:
PropertiesPanelNotifier { public void notifyPanel() { for (final Node node : getNodes()) { final Object definition = getDefinition(node); notifyVariables(node, definition); notifyExpressions(node, definition); } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testNotifyPanel() { final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Object definition1 = mock(Object.class); final Object definition2 = mock(Object.class); doReturn(asList(node1, node2)).when(notifier).getNodes(); doReturn(definition1).when(notifier).getDefinition(node1); doReturn(definition2).when(notifier).getDefinition(node2); notifier.notifyPanel(); verify(notifier).notifyVariables(node1, definition1); verify(notifier).notifyExpressions(node2, definition2); } |
### Question:
RuleAnnotationClauseConverter { public static RuleAnnotationClause wbFromDMN(final org.kie.dmn.model.api.RuleAnnotationClause ruleAnnotationClause) { if (ruleAnnotationClause == null) { return null; } final RuleAnnotationClause rule = new RuleAnnotationClause(); rule.setName(new Name(ruleAnnotationClause.getName())); return rule; } static RuleAnnotationClause wbFromDMN(final org.kie.dmn.model.api.RuleAnnotationClause ruleAnnotationClause); static org.kie.dmn.model.api.RuleAnnotationClause dmnFromWB(final RuleAnnotationClause wb); }### Answer:
@Test public void testWbFromDMN() { final String name = "name"; when(ruleAnnotationClause.getName()).thenReturn(name); final RuleAnnotationClause converted = RuleAnnotationClauseConverter.wbFromDMN(ruleAnnotationClause); assertEquals(name, converted.getName().getValue()); }
@Test public void testWbFromDMNWhenIsNull() { final RuleAnnotationClause converted = RuleAnnotationClauseConverter.wbFromDMN(null); assertNull(converted); } |
### Question:
PropertiesPanelNotifier { void onCanvasSelectionEvent(final @Observes CanvasSelectionEvent event) { final Collection<String> identifiers = event.getIdentifiers(); if (identifiers.size() > 0) { setSelectedElementUUID(identifiers.iterator().next()); } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testOnCanvasSelectionEvent() { final CanvasSelectionEvent selectionEvent = mock(CanvasSelectionEvent.class); final String uuid1 = "uuid1"; final String uuid2 = "uuid2"; final List<String> t = asList(uuid1, uuid2); when(selectionEvent.getIdentifiers()).thenReturn(t); notifier.onCanvasSelectionEvent(selectionEvent); verify(notifier).setSelectedElementUUID(uuid1); } |
### Question:
PropertiesPanelNotifier { void onDomainObjectSelectionEvent(final @Observes DomainObjectSelectionEvent event) { setSelectedElementUUID(event.getDomainObject().getDomainObjectUUID()); } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testOnDomainObjectSelectionEvent() { final DomainObjectSelectionEvent selectionEvent = mock(DomainObjectSelectionEvent.class); final DomainObject domainObject = mock(DomainObject.class); final String uuid = "uuid"; when(selectionEvent.getDomainObject()).thenReturn(domainObject); when(domainObject.getDomainObjectUUID()).thenReturn(uuid); notifier.onDomainObjectSelectionEvent(selectionEvent); verify(notifier).setSelectedElementUUID(uuid); } |
### Question:
PropertiesPanelNotifier { void notifyExpressions(final Node node, final Object definition) { if (definition instanceof HasExpression) { final HasExpression hasExpression = asHasExpression(definition); final List<HasTypeRef> hasTypeRefs = getNotNullHasTypeRefs(hasExpression.getExpression()); for (final HasTypeRef hasTypeRef : hasTypeRefs) { notifyOutdatedElement(node, hasTypeRef); } } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testNotifyExpressions() { final Node node = mock(Node.class); final HasExpression hasExpression = mock(HasExpression.class); final Expression expression = mock(Expression.class); final HasTypeRef hasTypeRef1 = mock(HasTypeRef.class); final HasTypeRef hasTypeRef2 = mock(HasTypeRef.class); when(expression.getHasTypeRefs()).thenReturn(asList(hasTypeRef1, hasTypeRef2)); when(hasExpression.getExpression()).thenReturn(expression); doNothing().when(notifier).notifyOutdatedElement(any(), any()); notifier.notifyExpressions(node, hasExpression); verify(notifier).notifyOutdatedElement(node, hasTypeRef1); verify(notifier).notifyOutdatedElement(node, hasTypeRef2); } |
### Question:
PropertiesPanelNotifier { void notifyVariables(final Node node, final Object definition) { if (definition instanceof HasVariable) { notifyOutdatedElement(node, asHasVariable(definition).getVariable()); } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testNotifyVariables() { final Node node = mock(Node.class); final HasVariable hasVariable = mock(HasVariable.class); final IsInformationItem informationItem = mock(IsInformationItem.class); when(hasVariable.getVariable()).thenReturn(informationItem); doNothing().when(notifier).notifyOutdatedElement(any(), any()); notifier.notifyVariables(node, hasVariable); verify(notifier).notifyOutdatedElement(node, informationItem); } |
### Question:
PropertiesPanelNotifier { Object getDefinition(final Node node) { final ViewImpl content = (ViewImpl) node.getContent(); return content.getDefinition(); } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testGetDefinition() { final Node node = mock(Node.class); final ViewImpl content = mock(ViewImpl.class); final Object expected = mock(Object.class); when(content.getDefinition()).thenReturn(expected); when(node.getContent()).thenReturn(content); final Object actual = notifier.getDefinition(node); assertEquals(expected, actual); } |
### Question:
PropertiesPanelNotifier { List<Node> getNodes() { final List<Node> nodes = new ArrayList<>(); getGraph().ifPresent(graph -> { graph.nodes().forEach(nodes::add); }); return nodes; } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testGetNodes() { final Graph graph = mock(Graph.class); final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Iterable<Node> expectedNodes = asList(node1, node2); when(graph.nodes()).thenReturn(expectedNodes); doReturn(Optional.of(graph)).when(notifier).getGraph(); final List<Node> actualNodes = notifier.getNodes(); assertEquals(expectedNodes, actualNodes); } |
### Question:
PropertiesPanelNotifier { Optional<Graph<?, Node>> getGraph() { final Optional<CanvasHandler> canvasHandler = getCurrentSession().map(ClientSession::getCanvasHandler); final Optional<Diagram> diagram = canvasHandler.map(CanvasHandler::getDiagram); return diagram.map(Diagram::getGraph); } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testGetGraph() { final ClientSession clientSession = mock(ClientSession.class); final CanvasHandler canvasHandler = mock(CanvasHandler.class); final Diagram diagram = mock(Diagram.class); final Optional<Graph> expected = Optional.of(mock(Graph.class)); when(diagram.getGraph()).thenReturn(expected.get()); when(canvasHandler.getDiagram()).thenReturn(diagram); when(clientSession.getCanvasHandler()).thenReturn(canvasHandler); when(sessionManager.getCurrentSession()).thenReturn(clientSession); final Optional<Graph<?, Node>> actual = notifier.getGraph(); assertEquals(expected, actual); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { public void update(final DataType dataType) { final String type = getTypeName(dataType); if (!isBuiltInType(type)) { dataTypeManager .from(dataType) .withRefreshedSubDataTypes(type); } } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testUpdateWhenDataTypeIsDefault() { final DataType dataType = mock(DataType.class); when(dataType.getType()).thenReturn(BuiltInType.STRING.getName()); handler.update(dataType); verify(dataTypeManager, never()).from(any(DataType.class)); verify(dataTypeManager, never()).withRefreshedSubDataTypes(anyString()); }
@Test public void testUpdateWhenDataTypeIsNotDefault() { final DataType dataType = mock(DataType.class); final String name = "city"; final String type = "tCity"; when(dataType.getName()).thenReturn(name); when(dataType.getType()).thenReturn(type); when(dataTypeManager.from(any(DataType.class))).thenReturn(dataTypeManager); when(dataTypeManager.withRefreshedSubDataTypes(anyString())).thenReturn(dataTypeManager); handler.update(dataType); final InOrder inOrder = Mockito.inOrder(dataTypeManager); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withRefreshedSubDataTypes(type); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { public List<DataType> refreshDependentDataTypes(final DataType dataType, final String oldItemDefinitionName) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.addAll(handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName)); affectedDataTypes.addAll(handleNestedDataTypeFieldUpdate(dataType)); return affectedDataTypes; } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testRefreshDependentDataTypes() { final DataType dataType = mock(DataType.class); final String oldItemDefinitionName = "oldItemDefinitionName"; final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); doReturn(asList(dataType0, dataType1)).when(handler).handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName); doReturn(asList(dataType2, dataType3)).when(handler).handleNestedDataTypeFieldUpdate(dataType); final List<DataType> expectedDataTypes = asList(dataType0, dataType1, dataType2, dataType3); final List<DataType> actualDataTypes = handler.refreshDependentDataTypes(dataType, oldItemDefinitionName); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { List<DataType> handleTopLevelDataTypeUpdate(final DataType dataType, final String oldItemDefinitionName) { return updateAllChildrenWithTheNewTypeName(dataType, oldItemDefinitionName); } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testHandleTopLevelDataTypeUpdate() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final List<DataType> expectedDataTypes = asList(dataType0, dataType1); final String oldItemDefinitionName = "oldItemDefinitionName"; doReturn(expectedDataTypes).when(handler).updateAllChildrenWithTheNewTypeName(dataType, oldItemDefinitionName); final List<DataType> actualDataTypes = handler.handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { void refreshSubDataType(final DataType dataType, final String newType) { final ItemDefinition itemDefinition = itemDefinitionStore.get(dataType.getUUID()); dataTypeManager.from(dataType).withType(newType); recordEngine.doUpdate(dataType, itemDefinition); refreshSubDataTypes(dataType, dataType.getType()); } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testRefreshSubDataType() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final String newType = "newType"; final String type = "type"; final String uuid = "uuid"; when(dataType.getType()).thenReturn(type); when(dataType.getUUID()).thenReturn(uuid); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(dataTypeManager.from(dataType)).thenReturn(dataTypeManager); when(dataTypeManager.withType(newType)).thenReturn(dataTypeManager); handler.refreshSubDataType(dataType, newType); final InOrder inOrder = Mockito.inOrder(dataTypeManager, dataTypeManager, recordEngine, handler); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withType(newType); inOrder.verify(recordEngine).doUpdate(dataType, itemDefinition); inOrder.verify(handler).refreshSubDataTypes(dataType, type); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { public void destroy(final DataType dataType) { final Optional<DataType> dataTypeParent = Optional.ofNullable(parent(dataType)); dataTypeParent.ifPresent(parent -> { parent.getSubDataTypes().remove(dataType); }); unIndex(dataType); } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testDestroy() { final String uuid = "uuid"; final String parentUUID = "parentUUID"; final String childUUID1 = "childUUID1"; final String childUUID2 = "childUUID2"; final String grandchildUUID1 = "grandchildUUID1"; final String grandchildUUID2 = "grandchildUUID2"; final DataType[] grandchildren = {makeDataType(grandchildUUID1), makeDataType(grandchildUUID2)}; final DataType[] children = {makeDataType(childUUID1), makeDataType(childUUID2, grandchildren)}; final DataType dataType = makeDataType(uuid, children); final DataType parent = makeDataType(parentUUID, dataType); doReturn(parent).when(handler).parent(dataType); handler.destroy(dataType); verify(dataTypeStore).unIndex(uuid); verify(dataTypeStore).unIndex(childUUID1); verify(dataTypeStore).unIndex(childUUID2); verify(dataTypeStore).unIndex(grandchildUUID1); verify(dataTypeStore).unIndex(grandchildUUID2); assertEquals(emptyList(), parent.getSubDataTypes()); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { public List<DataType> refreshDependentDataTypes(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.addAll(handleTopLevelDataTypes(dataType)); affectedDataTypes.addAll(handleNestedDataTypes(dataType)); return affectedDataTypes; } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testRefreshDependentDataTypes() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); doReturn(asList(dataType0, dataType1)).when(handler).handleTopLevelDataTypes(dataType); doReturn(asList(dataType2, dataType3)).when(handler).handleNestedDataTypes(dataType); final List<DataType> expectedDataTypes = asList(dataType0, dataType1, dataType2, dataType3); final List<DataType> actualDataTypes = handler.refreshDependentDataTypes(dataType); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
ItemDefinitionCreateHandler { public ItemDefinition appendItemDefinition() { final ItemDefinition itemDefinition = new ItemDefinition(); itemDefinitions().add(itemDefinition); return itemDefinition; } @Inject ItemDefinitionCreateHandler(final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore itemDefinitionStore); ItemDefinition appendItemDefinition(); ItemDefinition insertNested(final DataType record,
final DataType reference); ItemDefinition insertSibling(final DataType record,
final DataType reference,
final CreationType creationType); }### Answer:
@Test public void testAppendItemDefinition() { when(itemDefinitionUtils.all()).thenReturn(new ArrayList<>()); final ItemDefinition itemDefinition = handler.appendItemDefinition(); assertTrue(itemDefinitionUtils.all().contains(itemDefinition)); } |
### Question:
RuleAnnotationClauseConverter { public static org.kie.dmn.model.api.RuleAnnotationClause dmnFromWB(final RuleAnnotationClause wb) { if (wb == null) { return null; } final org.kie.dmn.model.api.RuleAnnotationClause rule = new TRuleAnnotationClause(); rule.setName(wb.getName().getValue()); return rule; } static RuleAnnotationClause wbFromDMN(final org.kie.dmn.model.api.RuleAnnotationClause ruleAnnotationClause); static org.kie.dmn.model.api.RuleAnnotationClause dmnFromWB(final RuleAnnotationClause wb); }### Answer:
@Test public void testDmnFromWB() { final String dmnName = "name"; final Name name = new Name(dmnName); when(dmnRuleAnnotationClause.getName()).thenReturn(name); final org.kie.dmn.model.api.RuleAnnotationClause converted = RuleAnnotationClauseConverter.dmnFromWB(dmnRuleAnnotationClause); assertEquals(dmnName, converted.getName()); }
@Test public void testDmnFromWBWhenIsNull() { final org.kie.dmn.model.api.RuleAnnotationClause converted = RuleAnnotationClauseConverter.dmnFromWB(null); assertNull(converted); } |
### Question:
DataTypeStore { public DataType get(final String uuid) { return dataTypes.get(uuid); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testGetWhenItReturnsNull() { assertNull(store.get("456")); }
@Test public void testGetWhenItDoesNotReturnNull() { assertNotNull(store.get(uuid)); assertEquals(dataType, store.get(uuid)); } |
### Question:
DataTypeStore { public void index(final String uuid, final DataType dataType) { dataTypes.put(uuid, dataType); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testIndex() { assertEquals(1, store.size()); final DataType secondDataType = mock(DataType.class); final String secondUUID = "789"; store.index(secondUUID, secondDataType); assertEquals(2, store.size()); assertEquals(dataType, store.get(uuid)); assertEquals(secondDataType, store.get(secondUUID)); } |
### Question:
DataTypeStore { public void clear() { dataTypes.clear(); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testClear() { store.clear(); assertEquals(0, store.size()); } |
### Question:
DataTypeStore { public List<DataType> getTopLevelDataTypes() { return all() .stream() .filter(DataType::isTopLevel) .collect(Collectors.toList()); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testGetTopLevelDataTypes() { final String secondUUID = "789"; final String thirdUUID = "012"; final DataType secondDataType = mock(DataType.class); final DataType thirdDataType = mock(DataType.class); when(secondDataType.isTopLevel()).thenReturn(true); store.index(secondUUID, secondDataType); store.index(thirdUUID, thirdDataType); final List<DataType> topLevelDataTypes = store.getTopLevelDataTypes(); assertEquals(topLevelDataTypes, singletonList(secondDataType)); } |
### Question:
DataTypeStore { public List<DataType> all() { return new ArrayList<>(dataTypes.values()); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testAll() { final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); store.index("0", dataType0); store.index("1", dataType1); final List<DataType> all = store.all(); assertEquals(3, all.size()); assertTrue(all.contains(dataType)); assertTrue(all.contains(dataType0)); assertTrue(all.contains(dataType1)); } |
### Question:
DataTypeActiveRecord extends ActiveRecord<DataType> { public List<DataType> create(final DataType reference, final CreationType creationType) { return getDataTypeRecordEngine().create(getRecord(), reference, creationType); } DataTypeActiveRecord(final RecordEngine<DataType> recordEngine); List<DataType> create(final DataType reference,
final CreationType creationType); List<DataType> destroyWithoutDependentTypes(); }### Answer:
@Test public void testCreate() { final DataTypeRecordEngine engine = makeRecordEngine(); final DataType record = spy(new DataType(engine)); final DataType reference = mock(DataType.class); final List<DataType> expectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final CreationType creationType = mock(CreationType.class); doReturn(expectedDataTypes).when(engine).create(record, reference, creationType); final List<DataType> actualDataTypes = record.create(reference, creationType); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeActiveRecord extends ActiveRecord<DataType> { public List<DataType> destroyWithoutDependentTypes() { return getDataTypeRecordEngine().destroyWithoutDependentTypes(getRecord()); } DataTypeActiveRecord(final RecordEngine<DataType> recordEngine); List<DataType> create(final DataType reference,
final CreationType creationType); List<DataType> destroyWithoutDependentTypes(); }### Answer:
@Test public void testDestroyWithoutDependentTypes() { final DataTypeRecordEngine engine = makeRecordEngine(); final DataType record = spy(new DataType(engine)); final List<DataType> expectedDataTypes = singletonList(mock(DataType.class)); doReturn(expectedDataTypes).when(engine).destroyWithoutDependentTypes(record); final List<DataType> actualDataTypes = record.destroyWithoutDependentTypes(); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @PostConstruct public void init() { dataTypeCreateHandler.init(this); dataTypeDestroyHandler.init(this); dataTypeUpdateHandler.init(this); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testInit() { recordEngine.init(); verify(dataTypeDestroyHandler).init(recordEngine); verify(dataTypeUpdateHandler).init(recordEngine); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { public void doUpdate(final DataType dataType, final ItemDefinition itemDefinition) { dataTypeUpdateHandler.update(dataType); itemDefinitionUpdateHandler.update(dataType, itemDefinition); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDoUpdate() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); recordEngine.doUpdate(dataType, itemDefinition); verify(dataTypeUpdateHandler).update(dataType); verify(itemDefinitionUpdateHandler).update(dataType, itemDefinition); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> destroy(final DataType dataType) { doDestroy(dataType); return refreshDependentDataTypesFromDestroyOperation(dataType); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDestroy() { final DataType dataType = mock(DataType.class); final List<DataType> expectedDependentDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeDestroyHandler.refreshDependentDataTypes(dataType)).thenReturn(expectedDependentDataTypes); final List<DataType> actualDependentDataTypes = recordEngine.destroy(dataType); verify(recordEngine).doDestroy(dataType); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> destroyWithoutDependentTypes(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.add(dataType); doDestroy(dataType, false); return affectedDataTypes; } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDestroyWithoutDependentTypes() { final DataType dataType = mock(DataType.class); final List<DataType> dependentDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeDestroyHandler.refreshDependentDataTypes(dataType)).thenReturn(dependentDataTypes); final List<DataType> actualDependentDataTypes = recordEngine.destroyWithoutDependentTypes(dataType); final List<DataType> expectedDependentDataTypes = singletonList(dataType); verify(dataTypeDestroyHandler).destroy(dataType); verify(itemDefinitionDestroyHandler).destroy(dataType, false); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> create(final DataType dataType) { return dataTypeCreateHandler.append(dataType, itemDefinitionCreateHandler.appendItemDefinition()); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testCreate() { final DataType dataType = mock(DataType.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(itemDefinitionCreateHandler.appendItemDefinition()).thenReturn(itemDefinition); when(dataTypeCreateHandler.append(dataType, itemDefinition)).thenReturn(expectedAffectedDataTypes); final List<DataType> actualAffectedDataTypes = recordEngine.create(dataType); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public boolean isValid(final DataType dataType) { return dataTypeNameValidator.isValid(dataType); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testIsValidWhenItIsTrue() { final DataType dataType = mock(DataType.class); doReturn(true).when(dataTypeNameValidator).isValid(dataType); assertTrue(recordEngine.isValid(dataType)); }
@Test public void testIsValidWhenItIsFalse() { final DataType dataType = mock(DataType.class); doReturn(false).when(dataTypeNameValidator).isValid(dataType); assertFalse(recordEngine.isValid(dataType)); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { public void doDestroy(final DataType dataType) { doDestroy(dataType, true); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDoDestroy() { final DataType dataType = mock(DataType.class); recordEngine.doDestroy(dataType); verify(dataTypeDestroyHandler).destroy(dataType); verify(itemDefinitionDestroyHandler).destroy(dataType, true); } |
### Question:
ExternalLinksConverter extends DMNModelInstrumentedBaseConverter { @Override protected void assignAttributes(final HierarchicalStreamReader reader, final Object parent) { superAssignAttributes(reader, parent); final ExternalLink externalLink = (ExternalLink) parent; externalLink.setName(reader.getAttribute(NAME)); externalLink.setUrl(reader.getAttribute(URL)); } ExternalLinksConverter(final XStream xstream); @Override boolean canConvert(final Class aClass); }### Answer:
@Test public void testAssignAttributes() { final ExternalLink externalLink = mock(ExternalLink.class); final HierarchicalStreamReader reader = mock(HierarchicalStreamReader.class); when(reader.getAttribute(NAME)).thenReturn(TEST_NAME); when(reader.getAttribute(URL)).thenReturn(TEST_URL); converter.assignAttributes(reader, externalLink); verify(externalLink).setName(TEST_NAME); verify(externalLink).setUrl(TEST_URL); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void init(final Presenter presenter) { this.presenter = presenter; typeRefEditor.addValueChangeHandler(e -> currentTypeRef = e.getValue()); setKeyDownListeners(); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInit() { verify(dataTypeEditor).addValueChangeHandler(valueChangeHandlerCaptor.capture()); valueChangeHandlerCaptor.getValue().onValueChange(valueChangeEvent); assertEquals(view.getCurrentTypeRef(), typeRef); verify(view).setKeyDownListeners(); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override protected void setKeyDownListeners() { super.setKeyDownListeners(); final Element manageButton = getManageButton(); manageButton.addEventListener(BrowserEvents.KEYDOWN, getManageButtonKeyDownEventListener(), false); final Element typeSelectorButton = getTypeSelectorButton(); typeSelectorButton.addEventListener(BrowserEvents.KEYDOWN, getTypeSelectorKeyDownEventListener(), false); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testSetKeyDownListeners() { reset(manageButton, typeSelectorButton); view.setKeyDownListeners(); verify(popoverElement).addEventListener(BrowserEvents.KEYDOWN, keyDownCallback, false); verify(manageButton).addEventListener(BrowserEvents.KEYDOWN, managerCallback, false); verify(typeSelectorButton).addEventListener(BrowserEvents.KEYDOWN, eventListenerCallback, false); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isTabKeyPressed(final KeyboardEvent event) { return Objects.equals(event.key, TAB_KEY); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsTabKeyPressed() { final KeyboardEvent keyboardEvent = mock(KeyboardEvent.class); keyboardEvent.key = TAB_KEY; boolean actual = view.isTabKeyPressed(keyboardEvent); assertTrue(actual); keyboardEvent.key = "A"; actual = view.isTabKeyPressed(keyboardEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isTab(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_TAB); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsTab() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_TAB); final boolean actual = view.isTab(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotTab() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isTab(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isEsc(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_ESCAPE); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsEsc() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ESCAPE); final boolean actual = view.isEsc(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotEsc() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isEsc(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isEnter(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_ENTER); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsEnter() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ENTER); final boolean actual = view.isEnter(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotEnter() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isEnter(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void setDMNModel(final DMNModelInstrumentedBase dmnModel) { typeRefEditor.setDMNModel(dmnModel); previousTypeRef = typeRefEditor.getValue(); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testSetDMNModel() { view.setDMNModel(decision); verify(dataTypeEditor).setDMNModel(eq(decision)); } |
### Question:
ExternalLinksConverter extends DMNModelInstrumentedBaseConverter { @Override protected void writeAttributes(final HierarchicalStreamWriter writer, final Object parent) { superWriteAttributes(writer, parent); final ExternalLink externalLink = (ExternalLink) parent; writer.addAttribute(URL, externalLink.getUrl()); writer.addAttribute(NAME, externalLink.getName()); } ExternalLinksConverter(final XStream xstream); @Override boolean canConvert(final Class aClass); }### Answer:
@Test public void testWriteAttributes() { final HierarchicalStreamWriter writer = mock(HierarchicalStreamWriter.class); final ExternalLink externalLink = new ExternalLink(); externalLink.setUrl(TEST_URL); externalLink.setName(TEST_NAME); converter.writeAttributes(writer, externalLink); verify(writer).addAttribute(URL, TEST_URL); verify(writer).addAttribute(NAME, TEST_NAME); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void initValue(final String value) { valueEditor.setValue(value); currentValue = value; previousValue = value; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInitValue() { view.initValue(VALUE); verify(valueEditor).setValue(eq(VALUE)); assertEquals(VALUE, view.getCurrentValue()); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void initSelectedTypeRef(final QName typeRef) { typeRefEditor.setValue(typeRef, false); currentTypeRef = typeRef; previousTypeRef = typeRef; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInitSelectedTypeRef() { view.initSelectedTypeRef(typeRef); verify(dataTypeEditor).setValue(eq(typeRef), eq(false)); assertEquals(typeRef, view.getCurrentTypeRef()); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void show(final Optional<String> popoverTitle) { valueLabel.setTextContent(presenter.getValueLabel()); getMonitor().show(popoverTitle); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testShow() { view.show(Optional.empty()); verify(valueLabel).setTextContent(VALUE_LABEL); verify(popover).show(); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueChange(final BlurEvent event) { final String value = valueEditor.getValue(); final String normalisedValue = presenter.normaliseValue(value); if (!Objects.equals(normalisedValue, value)) { valueEditor.setValue(normalisedValue); } currentValue = normalisedValue; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testOnValueChange() { when(presenter.normaliseValue(anyString())).thenAnswer(i -> i.getArguments()[0]); when(valueEditor.getValue()).thenReturn(VALUE); view.onValueChange(blurEvent); verify(presenter, never()).setValue(eq(VALUE)); assertEquals(VALUE, view.getCurrentValue()); } |
### Question:
DataTypesPage extends DMNPage { @PostConstruct public void init() { dataTypeShortcuts.init(treeList); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testInit() { page.init(); verify(dataTypeShortcuts).init(treeList); } |
### Question:
DataTypesPage extends DMNPage { @Override public void onLostFocus() { flashMessages.hideMessages(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testOnLostFocus() { page.onLostFocus(); verify(flashMessages).hideMessages(); } |
### Question:
DataTypesPage extends DMNPage { public void reload() { loadedDMNModelNamespace = currentDMNModelNamespace(); cleanDataTypeStore(); loadDataTypes(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testReload() { final String expected = "dmnModelNamespace"; doReturn(expected).when(page).currentDMNModelNamespace(); page.reload(); final String actual = page.getLoadedDMNModelNamespace(); verify(page).cleanDataTypeStore(); verify(page).loadDataTypes(); assertEquals(expected, actual); } |
### Question:
DataTypesPage extends DMNPage { void refreshPageView() { final HTMLDivElement pageView = getPageView(); RemoveHelper.removeChildren(pageView); pageView.appendChild(flashMessages.getElement()); pageView.appendChild(treeList.getElement()); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testRefreshPageView() { final HTMLElement flashMessagesElement = mock(HTMLElement.class); final HTMLElement treeListElement = mock(HTMLElement.class); final Element element = mock(Element.class); pageView.firstChild = element; when(pageView.removeChild(element)).then(a -> { pageView.firstChild = null; return element; }); when(flashMessages.getElement()).thenReturn(flashMessagesElement); when(treeList.getElement()).thenReturn(treeListElement); page.refreshPageView(); verify(pageView).removeChild(element); verify(pageView).appendChild(flashMessagesElement); verify(pageView).appendChild(treeListElement); } |
### Question:
DataTypesPage extends DMNPage { String currentDMNModelNamespace() { return getNamespace().map(Text::getValue).orElse(""); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testCurrentDMNModelNamespaceWhenDefinitionsIsNull() { when(dmnGraphUtils.getModelDefinitions()).thenReturn(null); final String actual = page.currentDMNModelNamespace(); final String expected = ""; assertEquals(expected, actual); }
@Test public void testCurrentDMNModelNamespace() { final Definitions definitions = mock(Definitions.class); final Text text = mock(Text.class); final String expected = "currentDMNModelNamespace"; when(text.getValue()).thenReturn(expected); when(definitions.getNamespace()).thenReturn(text); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); final String actual = page.currentDMNModelNamespace(); assertEquals(expected, actual); } |
### Question:
DMNDIExtensionsRegister implements DMNExtensionRegister { @Override public void registerExtensionConverters(final XStream xStream) { xStream.processAnnotations(ComponentsWidthsExtension.class); xStream.processAnnotations(ComponentWidths.class); xStream.processAnnotations(ExternalLink.class); xStream.alias(COMPONENT_WIDTH_ALIAS, Double.class); xStream.alias(EXTERNAL_LINK_ALIAS, ExternalLink.class); xStream.registerConverter(new ExternalLinksConverter(xStream)); xStream.registerConverter(new ComponentWidthsConverter(xStream)); } @Override void registerExtensionConverters(final XStream xStream); @Override void beforeMarshal(final Object o,
final QNameMap qmap); }### Answer:
@Test public void testRegisterExtensionConverters() { register.registerExtensionConverters(xStream); verify(xStream).processAnnotations(eq(ComponentsWidthsExtension.class)); verify(xStream).processAnnotations(eq(ComponentWidths.class)); verify(xStream).processAnnotations(eq(ExternalLink.class)); verify(xStream).alias(eq(COMPONENT_WIDTH_ALIAS), eq(Double.class)); verify(xStream, times(2)).registerConverter(converterCaptor.capture()); verify(xStream).alias(eq(EXTERNAL_LINK_ALIAS), eq(ExternalLink.class)); final List<Converter> values = converterCaptor.getAllValues(); assertThat(values).hasAtLeastOneElementOfType(ComponentWidthsConverter.class); assertThat(values).hasAtLeastOneElementOfType(ExternalLinksConverter.class); } |
### Question:
DataTypesPage extends DMNPage { void cleanDataTypeStore() { definitionStore.clear(); dataTypeStore.clear(); stackIndex.clear(); searchBar.reset(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testCleanDataTypeStore() { page.cleanDataTypeStore(); verify(definitionStore).clear(); verify(dataTypeStore).clear(); verify(stackIndex).clear(); verify(searchBar).reset(); } |
### Question:
DataTypesPage extends DMNPage { DataType makeDataType(final ItemDefinition itemDefinition) { return dataTypeManager.from(itemDefinition).get(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testMakeDataType() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final DataType expectedDataType = mock(DataType.class); when(dataTypeManager.from(itemDefinition)).thenReturn(dataTypeManager); when(dataTypeManager.get()).thenReturn(expectedDataType); final DataType actualDataType = page.makeDataType(itemDefinition); assertEquals(expectedDataType, actualDataType); } |
### Question:
DataTypesPage extends DMNPage { public void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event) { onFocus(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testOnDataTypePageNavTabActiveEvent() { page.onDataTypePageNavTabActiveEvent(mock(DataTypePageTabActiveEvent.class)); verify(page).onFocus(); } |
### Question:
DataTypesPage extends DMNPage { public void enableShortcuts() { dataTypeShortcuts.setup(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testEnableShortcuts() { page.enableShortcuts(); verify(dataTypeShortcuts).setup(); } |
### Question:
DataTypesPage extends DMNPage { public void disableShortcuts() { dataTypeShortcuts.teardown(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testDisableShortcuts() { page.disableShortcuts(); verify(dataTypeShortcuts).teardown(); } |
### Question:
DataTypeNameFormatValidator { public void ifIsValid(final DataType dataType, final Command onSuccess) { final String dataTypeName = dataType.getName(); clientServicesProxy.isValidVariableName(dataTypeName, getCallback(dataType, onSuccess)); } @Inject DataTypeNameFormatValidator(final DMNClientServicesProxy clientServicesProxy,
final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsInvalidErrorMessage nameIsInvalidErrorMessage); void ifIsValid(final DataType dataType,
final Command onSuccess); }### Answer:
@Test @SuppressWarnings("unchecked") public void testIfIsValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final String dataTypeName = "name"; when(dataType.getName()).thenReturn(dataTypeName); validator.ifIsValid(dataType, onSuccess); verify(clientServicesProxy).isValidVariableName(eq(dataTypeName), any(ServiceCallback.class)); } |
### Question:
DataTypeNameFormatValidator { ServiceCallback<Boolean> getCallback(final DataType dataType, final Command onSuccess) { return new ServiceCallback<Boolean>() { @Override public void onSuccess(final Boolean isValid) { if (isValid) { onSuccess.execute(); } else { flashMessageEvent.fire(nameIsInvalidErrorMessage.getFlashMessage(dataType)); } } @Override public void onError(final ClientRuntimeError error) { clientServicesProxy.logWarning(error); } }; } @Inject DataTypeNameFormatValidator(final DMNClientServicesProxy clientServicesProxy,
final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsInvalidErrorMessage nameIsInvalidErrorMessage); void ifIsValid(final DataType dataType,
final Command onSuccess); }### Answer:
@Test public void testGetCallbackWhenIsValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final FlashMessage flashMessage = mock(FlashMessage.class); when(nameIsInvalidErrorMessage.getFlashMessage(dataType)).thenReturn(flashMessage); validator.getCallback(dataType, onSuccess).onSuccess(true); verify(onSuccess).execute(); verify(flashMessageEvent, never()).fire(flashMessage); }
@Test public void testGetCallbackWhenIsNotValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final FlashMessage flashMessage = mock(FlashMessage.class); when(nameIsInvalidErrorMessage.getFlashMessage(dataType)).thenReturn(flashMessage); validator.getCallback(dataType, onSuccess).onSuccess(false); verify(flashMessageEvent).fire(flashMessage); verify(onSuccess, never()).execute(); } |
### Question:
DataTypeConstraint { @PostConstruct void setup() { view.init(this); disableEditMode(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testSetup() { dataTypeConstraint.setup(); verify(view).init(dataTypeConstraint); verify(dataTypeConstraint).disableEditMode(); } |
### Question:
DataTypeConstraint { public void init(final DataTypeListItem listItem) { this.listItem = listItem; this.constraintValue = listItem.getDataType().getConstraint(); this.constraintType = listItem.getDataType().getConstraintType(); refreshView(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testInit() { final DataTypeListItem expectedListItem = mock(DataTypeListItem.class); final DataType datatype = mock(DataType.class); final String expectedConstraint = "constraint"; final ConstraintType expectedType = mock(ConstraintType.class); when(expectedListItem.getDataType()).thenReturn(datatype); when(datatype.getConstraint()).thenReturn(expectedConstraint); when(datatype.getConstraintType()).thenReturn(expectedType); dataTypeConstraint.init(expectedListItem); final DataTypeListItem actualListItem = dataTypeConstraint.getListItem(); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualType = dataTypeConstraint.getConstraintType(); assertEquals(expectedType, actualType); assertEquals(expectedListItem, actualListItem); assertEquals(expectedConstraint, actualConstraint); verify(dataTypeConstraint).refreshView(); } |
### Question:
DataTypeConstraint { public HTMLElement getElement() { return view.getElement(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testGetElement() { final HTMLElement expectedElement = mock(HTMLElement.class); when(view.getElement()).thenReturn(expectedElement); final HTMLElement actualElement = dataTypeConstraint.getElement(); assertEquals(expectedElement, actualElement); } |
### Question:
DataTypeConstraint { public void enableEditMode() { isEditModeEnabled = true; view.showAnchor(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testEnableEditMode() { dataTypeConstraint.enableEditMode(); assertTrue(dataTypeConstraint.isEditModeEnabled()); verify(view).showAnchor(); } |
### Question:
DataTypeConstraint { public void disableEditMode() { isEditModeEnabled = false; view.hideAnchor(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testDisableEditMode() { dataTypeConstraint.disableEditMode(); assertFalse(dataTypeConstraint.isEditModeEnabled()); verify(view).hideAnchor(); } |
### Question:
DataTypeConstraint { void openModal() { constraintModal().load(getListItem().getType(), getValue(), getConstraintType()); constraintModal().show(getOnShowConsumer()); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testOpenModal() { final DataTypeListItem listItem = mock(DataTypeListItem.class); final String constraint = "1,2,3"; final String type = "string"; final BiConsumer<String, ConstraintType> onShowConsumer = (s, c) -> { }; doReturn(listItem).when(dataTypeConstraint).getListItem(); doReturn(constraint).when(dataTypeConstraint).getValue(); doReturn(onShowConsumer).when(dataTypeConstraint).getOnShowConsumer(); when(listItem.getType()).thenReturn(type); dataTypeConstraint.openModal(); constraintModal.load(type, constraint, ENUMERATION); constraintModal.show(onShowConsumer); } |
### Question:
DataTypeConstraint { BiConsumer<String, ConstraintType> getOnShowConsumer() { return (newConstraintValue, newConstraintType) -> { setConstraint(newConstraintValue, newConstraintType); refreshView(); }; } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testGetOnShowConsumer() { final String expectedConstraint = "1,2,3"; final ConstraintType expectedConstraintType = ENUMERATION; dataTypeConstraint.getOnShowConsumer().accept(expectedConstraint, ENUMERATION); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualConstraintType = dataTypeConstraint.getConstraintType(); assertEquals(expectedConstraint, actualConstraint); assertEquals(expectedConstraintType, actualConstraintType); verify(dataTypeConstraint).refreshView(); } |
### Question:
DataTypeConstraint { public void disable() { setConstraint(NONE, ConstraintType.NONE); view.disable(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testDisable() { dataTypeConstraint.disable(); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualConstraintType = dataTypeConstraint.getConstraintType(); assertEquals(DataTypeConstraint.NONE, actualConstraint); assertEquals(ConstraintType.NONE, actualConstraintType); verify(view).disable(); } |
### Question:
DataTypeConstraint { public void enable() { view.enable(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testEnable() { dataTypeConstraint.enable(); verify(view).enable(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.