method2testcases stringlengths 118 3.08k |
|---|
### Question:
ThemeExtractor implements Serializable { long getThemeLastUpdateDateFromEngine(final APISession apiSession, ThemeType themeType) throws BonitaHomeNotSetException, ServerAPIException, UnknownAPITypeException { final ThemeAPI themeAPI = getThemeAPI(apiSession); return themeAPI.getLastUpdateDate(themeType).getTime(); } ThemeExtractor(); void retrieveAndExtractCurrentTheme(File themeFolder, APISession apiSession, ThemeType themeType); }### Answer:
@Test public void getThemeLastUpdateDateFromEngine_should_call_getLastUpdateDate_on_Engine() throws Exception { themeExtractor.getThemeLastUpdateDateFromEngine(session, ThemeType.PORTAL); verify(themeAPI).getLastUpdateDate(ThemeType.PORTAL); } |
### Question:
Value { public V cast() { return converter.convert(value); } Value(String value, ValueConverter<V> converter); V cast(); }### Answer:
@Test public void testName() throws Exception { @SuppressWarnings("unchecked") ValueConverter<Long> converter = mock(ValueConverter.class); doReturn(5L).when(converter).convert("12"); Value<Long> value = new Value<Long>("12", converter); assertEquals(Long.valueOf(5), value.cast()); } |
### Question:
FilterAccessor { public String getMandatory(String filter) { ensureFilterValue(filter); return getFilters().get(filter); } FilterAccessor(Map<String, String> filters); String getMandatory(String filter); S getMandatory(String filter, ValueConverter<S> converter); }### Answer:
@Test public void testWeCanRetrieveMandatoryValue() throws Exception { FilterAccessor filterAccess = new FilterAccessor(Collections.singletonMap("key", "value")); String value = filterAccess.getMandatory("key"); assertEquals("value", value); }
@Test(expected = APIFilterMandatoryException.class) public void testAccessToMandatoryValueWhichItDoesntExitThrowException() { FilterAccessor filterAccess = new FilterAccessor(Collections.<String, String> emptyMap()); filterAccess.getMandatory("key"); }
@Test(expected = APIFilterMandatoryException.class) public void testAccessToMandatoryValueNotConvertibleThrowException() { FilterAccessor filterAccess = new FilterAccessor(Collections.singletonMap("key", "value")); filterAccess.getMandatory("key", new MemberTypeConverter()); } |
### Question:
Filter { public String getField() { return field.toString(); } Filter(Field field, Value<V> value); Filter(Field field, Value<V> value, Operator operator); String getField(); V getValue(); Operator getOperator(); }### Answer:
@Test public void testFilterField() throws Exception { Mockito.doReturn("field").when(field).toString(); Filter<String> filter = new Filter<String>(field, value); Assert.assertEquals("field", filter.getField()); } |
### Question:
Filter { public V getValue() { return value != null ? value.cast() : null; } Filter(Field field, Value<V> value); Filter(Field field, Value<V> value, Operator operator); String getField(); V getValue(); Operator getOperator(); }### Answer:
@Test public void testFilterValue() throws Exception { Mockito.doReturn("value").when(value).cast(); Filter<String> filter = new Filter<String>(field, value); Assert.assertEquals("value", filter.getValue()); } |
### Question:
LongValue extends Value<Long> { public LongValue(String value) { super(value, new LongValueConverter()); } LongValue(String value); }### Answer:
@Test public void testLongValue() { LongValue value = new LongValue("8"); assertEquals(Long.valueOf(8), value.cast()); } |
### Question:
Filters { public List<Filter<?>> asList() { return filters; } Filters(final Map<String, String> filters, final FilterCreator filterCreator); Filters(final Map<String, String> filters); List<Filter<?>> asList(); }### Answer:
@Test public void testFiltersListWithoutFilterCreator() throws Exception { when(fiedConverter.convert("field")) .thenReturn("field"); Filters filters = new Filters(aMapWith(new Arg("field", "value")), new GenericFilterCreator(fiedConverter)); List<Filter<?>> filterList = filters.asList(); Assert.assertEquals("field", filterList.get(0).getField()); Assert.assertEquals("value", filterList.get(0).getValue()); }
@Test public void testFilterListWithMultiTypeFilterCreator() throws Exception { Map<String, String> map = aMapWith(new Arg("field1", "value"), new Arg("field2", "value")); doReturn(longFilter).when(filterCreator).create(eq("field1"), anyString()); doReturn(strFilter).when(filterCreator).create(eq("field2"), anyString()); Filters filters = new Filters(map, filterCreator); assertTrue(IsRightValue(filters.asList().get(0))); assertTrue(IsRightValue(filters.asList().get(1))); } |
### Question:
GenericFilterCreator implements FilterCreator { @Override public Filter<? extends Serializable> create(String attribute, String value) { return new Filter<>(new Field(attribute, fieldConverter), getTypedValue(attribute, value)); } GenericFilterCreator(AttributeConverter fieldConverter); @Override Filter<? extends Serializable> create(String attribute, String value); }### Answer:
@Test public void method_create_should_handle_value_as_String_by_default() { GenericFilterCreator creator = new GenericFilterCreator(new AttributeConverter() { @Override public String convert(String attribute) { return attribute; } @Override public Map<String, ItemAttribute.TYPE> getValueTypeMapping() { return Collections.emptyMap(); } }); Filter<? extends Serializable> filter = creator.create("attribute", "value"); assertEquals("attribute", filter.getField()); assertEquals("value", filter.getValue()); }
@Test public void method_create_should_handle_boolean_values() { AttributeConverter converter = new AttributeConverter() { @Override public String convert(String attribute) { return attribute; } @Override public Map<String, ItemAttribute.TYPE> getValueTypeMapping() { return Collections.singletonMap("myAttribute", ItemAttribute.TYPE.BOOLEAN); } }; GenericFilterCreator creator = new GenericFilterCreator(converter); Filter<? extends Serializable> filter = creator.create("myAttribute", "true"); assertThat(filter.getValue()).isEqualTo(true); } |
### Question:
ThemeExtractor implements Serializable { void updateThemeFromEngine(ThemeArchive themeArchive, final APISession apiSession, final File portalThemeDirectory, final File timestampFile, final long lastUpdateTimestamp, ThemeType themeType) throws BonitaHomeNotSetException, ServerAPIException, UnknownAPITypeException, IOException { final Theme theme = getThemeAPI(apiSession).getCurrentTheme(themeType); themeArchive.setZippedTheme(theme.getContent()); final ThemeArchive.ThemeModifier themeModifier = themeArchive.extract(portalThemeDirectory); switch (themeType) { case PORTAL: extractPortalSpecificTheme(themeModifier, theme); break; case MOBILE: break; } writeTimeStampToFile(timestampFile, lastUpdateTimestamp); } ThemeExtractor(); void retrieveAndExtractCurrentTheme(File themeFolder, APISession apiSession, ThemeType themeType); }### Answer:
@Test public void updateThemeFromEngine_should_retrieve_theme_from_Engine_and_compile() throws Exception { doReturn(mock(Theme.class)).when(themeAPI).getCurrentTheme(ThemeType.PORTAL); doReturn(themeModifier).when(themeArchive).extract(any(File.class)); doReturn(themeModifier).when(themeModifier).compile(CompilableFile.ALWAYS_COMPILED_FILES); doReturn(themeModifier).when(themeModifier).add(anyString(), any(byte[].class)); final File folder = tempFolderRule.newFolder(); final File lastUpdateFile = tempFolderRule.newFile(); themeExtractor.updateThemeFromEngine(themeArchive, session, folder, lastUpdateFile, new Date().getTime(), ThemeType.PORTAL); verify(themeAPI).getCurrentTheme(ThemeType.PORTAL); } |
### Question:
ApplicationDataStore extends CommonDatastore<ApplicationItem, Application> implements DatastoreHasAdd<ApplicationItem>,
DatastoreHasUpdate<ApplicationItem>,
DatastoreHasGet<ApplicationItem>,DatastoreHasSearch<ApplicationItem>, DatastoreHasDelete { @Override public ApplicationItem get(final APIID id) { try { final Application application = applicationAPI.getApplication(id.toLong()); return converter.toApplicationItem(application); } catch (final Exception e) { throw new APIException(e); } } ApplicationDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI, final ApplicationItemConverter converter); @Override void delete(final List<APIID> ids); @Override ApplicationItem get(final APIID id); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_return_the_good_application_on_get() throws Exception { final ApplicationImpl application = new ApplicationImpl("app", "1.0", "app desc"); final ApplicationItem item = new ApplicationItem(); given(converter.toApplicationItem(application)).willReturn(item); application.setId(1); given(applicationAPI.getApplication(1)).willReturn(application); final ApplicationItem retrivedItem = dataStore.get(APIID.makeAPIID("1")); assertThat(retrivedItem).isEqualTo(item); }
@Test(expected = APIException.class) public void should_return_throw_APIException_on_get_when_engine_throws_exception() throws Exception { given(applicationAPI.getApplication(1)).willThrow(new ApplicationNotFoundException(1)); dataStore.get(APIID.makeAPIID("1")); } |
### Question:
ApplicationDataStore extends CommonDatastore<ApplicationItem, Application> implements DatastoreHasAdd<ApplicationItem>,
DatastoreHasUpdate<ApplicationItem>,
DatastoreHasGet<ApplicationItem>,DatastoreHasSearch<ApplicationItem>, DatastoreHasDelete { @Override public void delete(final List<APIID> ids) { try { for(final APIID id :ids){ applicationAPI.deleteApplication(id.toLong()); } } catch (final Exception e) { throw new APIException(e); } } ApplicationDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI, final ApplicationItemConverter converter); @Override void delete(final List<APIID> ids); @Override ApplicationItem get(final APIID id); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_delete_the_good_Application_on_delete() throws Exception { dataStore.delete(Arrays.<APIID>asList(APIID.makeAPIID("1"),APIID.makeAPIID("2"))); verify(applicationAPI, times(1)).deleteApplication(1); verify(applicationAPI, times(1)).deleteApplication(2); }
@Test(expected = APIException.class) public void should_throw_APIException_on_delete_when_engine_throws_exception() throws Exception { doThrow(new DeletionException("")).when(applicationAPI).deleteApplication(1); dataStore.delete(Arrays.<APIID> asList(APIID.makeAPIID("1"))); } |
### Question:
ApplicationDataStore extends CommonDatastore<ApplicationItem, Application> implements DatastoreHasAdd<ApplicationItem>,
DatastoreHasUpdate<ApplicationItem>,
DatastoreHasGet<ApplicationItem>,DatastoreHasSearch<ApplicationItem>, DatastoreHasDelete { @Override public ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { final SearchOptionsCreator creator = makeSearchOptionCreator(page, resultsByPage, search, orders, filters); SearchResult<Application> searchResult; try { searchResult = runSearch(creator); return new ItemSearchResult<ApplicationItem>(page, resultsByPage, searchResult.getCount(), convertEngineToConsoleItemsList(searchResult.getResult())); } catch (final SearchException e) { throw new APIException(e); } } ApplicationDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI, final ApplicationItemConverter converter); @Override void delete(final List<APIID> ids); @Override ApplicationItem get(final APIID id); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test(expected = APIException.class) public void should_throw_APIException_on_search_when_engine_throws_exception() throws Exception { given(applicationAPI.searchApplications(any(SearchOptions.class))).willThrow(new SearchException(new Exception())); final String orders = ApplicationItem.ATTRIBUTE_TOKEN + " DESC"; dataStore.search(1, 2, "search", orders, Collections.<String, String> emptyMap()); } |
### Question:
ApplicationItemConverter { public ApplicationCreator toApplicationCreator(final ApplicationItem appItem) { final ApplicationCreator creator = new ApplicationCreator(appItem.getToken(), appItem.getDisplayName(), appItem.getVersion()); creator.setDescription(appItem.getDescription()); creator.setProfileId(appItem.getProfileId().toLong()); creator.setIconPath(appItem.getIconPath()); return creator; } ApplicationItem toApplicationItem(final Application application); ApplicationCreator toApplicationCreator(final ApplicationItem appItem); ApplicationUpdater toApplicationUpdater(final Map<String, String> attributes); }### Answer:
@Test public void toApplicationCreator_should_map_all_fields() throws Exception { final ApplicationItem item = new ApplicationItem(); item.setToken(TOKEN); item.setDisplayName(DISPLAY_NAME); item.setVersion(VERSION); item.setDescription(DESCRIPTION); item.setIconPath(ICON_PATH); item.setProfileId(PROFILE_ID); final ApplicationCreator creator = converter.toApplicationCreator(item); assertThat(creator).isNotNull(); final Map<ApplicationField, Serializable> fields = creator.getFields(); assertThat(fields.get(ApplicationField.TOKEN)).isEqualTo(TOKEN); assertThat(fields.get(ApplicationField.DISPLAY_NAME)).isEqualTo(DISPLAY_NAME); assertThat(fields.get(ApplicationField.VERSION)).isEqualTo(VERSION); assertThat(fields.get(ApplicationField.DESCRIPTION)).isEqualTo(DESCRIPTION); assertThat(fields.get(ApplicationField.ICON_PATH)).isEqualTo(ICON_PATH); assertThat(fields.get(ApplicationField.PROFILE_ID)).isEqualTo(PROFILE_ID); } |
### Question:
ApplicationResourceServlet extends HttpServlet { protected long getTenantID(final HttpServletRequest request) throws NoCredentialsInSessionException { final HttpSession httpSession = request.getSession(); final APISession aAPISession = (APISession) httpSession.getAttribute(SessionUtil.API_SESSION_PARAM_KEY); return aAPISession.getTenantId(); } static final String PROCESS_ID_PARAM; static final String WEB_RESOURCES_DIR; static final String RESOURCE_PATH_PARAM; static final String API_SESSION_PARAM_KEY; static final String USER_SESSION_PARAM_KEY; }### Answer:
@Test public void should_verify_authorisation_for_the_given_location_param() throws Exception { final ApplicationResourceServlet applicationResourceServlet = spy(new ApplicationResourceServlet()); when(req.getParameter("process")).thenReturn("processUUIDStr"); when(req.getParameter("location")).thenReturn("../../../file.txt"); when(req.getMethod()).thenReturn("GET"); when(req.getSession()).thenReturn(httpSession); when(httpSession.getAttribute("apiSession")).thenReturn(session); when(session.getTenantId()).thenReturn(1L); when(req.getParameter("tenant")).thenReturn("1"); when(applicationResourceServlet.getTenantID(req)).thenReturn(1L); final File process = new File(WebBonitaConstantsUtils.getInstance(1L).getFormsWorkFolder().getAbsolutePath(), "processUUIDStr"); process.mkdirs(); final File processDeployement = new File(process.getAbsolutePath(), "1"); processDeployement.mkdirs(); try { applicationResourceServlet.service(req, res); } catch (final ServletException e) { assertTrue(e.getCause().getMessage().startsWith("For security reasons, access to this file paths")); } } |
### Question:
UserLoggerFactory { public static UserLogger getUserLogger() { ServerProperties serverProperties = ServerProperties.getInstance(); String userLoggerClassName = serverProperties.getValue(USERLOGGER_PROPERTY_NAME); UserLogger userLogger; if (userLoggerClassName == null || userLoggerClassName.isEmpty()) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.log(Level.FINEST, "auth.UserLogger is undefined. Using default implementation : " + UserLogger.class.getName()); } userLogger = new UserLogger(); } else { try { userLogger = (UserLogger) Class.forName(userLoggerClassName).newInstance(); } catch (Exception e) { LOGGER.log(Level.SEVERE, "The UserLogger specified " + userLoggerClassName + " could not be instantiated! Using default implementation : " + UserLogger.class.getName(), e); userLogger = new UserLogger(); } } return userLogger; } static UserLogger getUserLogger(); }### Answer:
@Test public void should_return_UserLogger() { assertThat(UserLoggerFactory.getUserLogger()).isInstanceOf(UserLogger.class); } |
### Question:
ApplicationMenuSearchDescriptorConverter implements AttributeConverter { @Override public String convert(final String attribute) { return MapUtil.getMandatory(mapping, attribute); } ApplicationMenuSearchDescriptorConverter(); @Override String convert(final String attribute); @Override Map<String, ItemAttribute.TYPE> getValueTypeMapping(); }### Answer:
@Test public void should_return_ApplicationMenuSearchDescriptor_id_on_convert_attribute_id() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_ID); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.ID); }
@Test public void should_return_ApplicationMenuSearchDescriptor_display_name_on_convert_attribute_display_name() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_DISPLAY_NAME); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.DISPLAY_NAME); }
@Test public void should_return_ApplicationMenuSearchDescriptor_applicationPageId_on_convert_attribute_applicationPageId() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_APPLICATION_PAGE_ID); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.APPLICATION_PAGE_ID); }
@Test public void should_return_ApplicationMenuSearchDescriptor_applicationId_on_convert_attribute_applicationId() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_APPLICATION_ID); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.APPLICATION_ID); }
@Test public void should_return_ApplicationMenuSearchDescriptor_index_on_convert_attribute_menu_index() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_MENU_INDEX); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.INDEX); }
@Test public void should_return_ApplicationMenuSearchDescriptor_index_on_convert_attribute_parent_menu() throws Exception { final String convertedValue = converter.convert(ApplicationMenuItem.ATTRIBUTE_PARENT_MENU_ID); assertThat(convertedValue).isEqualTo(ApplicationMenuSearchDescriptor.PARENT_ID); } |
### Question:
ResourceLocationReader { public String getResourceLocationFromRequest(final HttpServletRequest request) { String fileName = request.getParameter(LOCATION_PARAM); if (fileName == null) { final String pathInfo = request.getPathInfo(); if (pathInfo != null && pathInfo.startsWith("/") && pathInfo.length() > 1) { fileName = pathInfo.substring(1); } } return fileName; } String getResourceLocationFromRequest(final HttpServletRequest request); final static String LOCATION_PARAM; }### Answer:
@Test public void should_use_infopath_if_location_param_is_not_defined() throws Exception { when(req.getParameter("location")).thenReturn(null); when(req.getPathInfo()).thenReturn("/bonita.css"); final String resourceLocation = resourceLocationReader.getResourceLocationFromRequest(req); verify(req, times(1)).getPathInfo(); assertThat(resourceLocation).isEqualTo("bonita.css"); }
@Test public void should_not_use_infopath_if_location_param_is_defined() throws Exception { when(req.getParameter("location")).thenReturn("bonita.css"); final String resourceLocation = resourceLocationReader.getResourceLocationFromRequest(req); verify(req, never()).getPathInfo(); assertThat(resourceLocation).isEqualTo("bonita.css"); } |
### Question:
ApplicationMenuItemConverter { public ApplicationMenuCreator toApplicationMenuCreator(final ApplicationMenuItem item) { Long applicationId = null; if (item.getApplicationId() != null) { applicationId = item.getApplicationId().toLong(); } Long applicationPageId = null; if (item.getApplicationPageId() != null) { applicationPageId = item.getApplicationPageId().toLong(); } final ApplicationMenuCreator menuCreator = new ApplicationMenuCreator(applicationId, item.getDisplayName(), applicationPageId); if (item.getParentMenuId() != null) { menuCreator.setParentId(item.getParentMenuId().toLong()); } return menuCreator; } ApplicationMenuItem toApplicationMenuItem(final ApplicationMenu applicationMenu); ApplicationMenuCreator toApplicationMenuCreator(final ApplicationMenuItem item); ApplicationMenuUpdater toApplicationMenuUpdater(final Map<String, String> attributes); }### Answer:
@Test public void toApplicationMenuCreator_should_map_all_fields() throws Exception { final ApplicationMenuItem item = new ApplicationMenuItem(); item.setDisplayName(DISPLAY_NAME); item.setApplicationId(APPLICATION_ID); item.setApplicationPageId(APPLICATION_PAGE_ID); item.setMenuIndex(INDEX); item.setParentMenuId(PARENT_MENU_ID); final ApplicationMenuCreator creator = converter.toApplicationMenuCreator(item); assertThat(creator).isNotNull(); final Map<ApplicationMenuField, Serializable> fields = creator.getFields(); assertThat(fields.get(ApplicationMenuField.DISPLAY_NAME)).isEqualTo(DISPLAY_NAME); assertThat(fields.get(ApplicationMenuField.APPLICATION_ID)).isEqualTo(APPLICATION_ID); assertThat(fields.get(ApplicationMenuField.APPLICATION_PAGE_ID)).isEqualTo(APPLICATION_PAGE_ID); assertThat(fields.get(ApplicationMenuField.PARENT_ID)).isEqualTo(PARENT_MENU_ID); } |
### Question:
ApplicationMenuDataStore extends CommonDatastore<ApplicationMenuItem, ApplicationMenu> implements DatastoreHasAdd<ApplicationMenuItem>,
DatastoreHasUpdate<ApplicationMenuItem>,
DatastoreHasGet<ApplicationMenuItem>, DatastoreHasSearch<ApplicationMenuItem>, DatastoreHasDelete { @Override public ApplicationMenuItem add(final ApplicationMenuItem item) { try { final ApplicationMenu applicationMenu = applicationAPI.createApplicationMenu(converter.toApplicationMenuCreator(item)); return converter.toApplicationMenuItem(applicationMenu); } catch (final Exception e) { throw new APIException(e); } } ApplicationMenuDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final ApplicationMenuItemConverter converter); @Override ApplicationMenuItem add(final ApplicationMenuItem item); @Override ApplicationMenuItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationMenuItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationMenuItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_return_result_of_engine_call_converted_to_item_on_add() throws Exception { final ApplicationMenuItem itemToCreate = new ApplicationMenuItem(); final ApplicationMenuImpl applicationMenu = new ApplicationMenuImpl("firstMenu", 11L, 14L, 1); given(applicationAPI.createApplicationMenu(any(ApplicationMenuCreator.class))).willReturn(applicationMenu); given(converter.toApplicationMenuItem(applicationMenu)).willReturn(new ApplicationMenuItem()); final ApplicationMenuItem createdItem = dataStore.add(itemToCreate); assertThat(createdItem).isEqualTo(itemToCreate); }
@Test(expected = APIException.class) public void should_throw_APIException_when_engine_throws_CreationException_on_add() throws Exception { given(applicationAPI.createApplicationMenu(any(ApplicationMenuCreator.class))).willThrow(new CreationException("")); dataStore.add(new ApplicationMenuItem()); } |
### Question:
ApplicationMenuDataStore extends CommonDatastore<ApplicationMenuItem, ApplicationMenu> implements DatastoreHasAdd<ApplicationMenuItem>,
DatastoreHasUpdate<ApplicationMenuItem>,
DatastoreHasGet<ApplicationMenuItem>, DatastoreHasSearch<ApplicationMenuItem>, DatastoreHasDelete { @Override public ApplicationMenuItem get(final APIID id) { try { final ApplicationMenu applicationMenu = applicationAPI.getApplicationMenu(id.toLong()); return converter.toApplicationMenuItem(applicationMenu); } catch (final Exception e) { throw new APIException(e); } } ApplicationMenuDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final ApplicationMenuItemConverter converter); @Override ApplicationMenuItem add(final ApplicationMenuItem item); @Override ApplicationMenuItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationMenuItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationMenuItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_return_the_ApplicationMenu_supplied_by_the_engine_converted_to_item_on_get() throws Exception { final ApplicationMenuItem itemToCreate = new ApplicationMenuItem(); final ApplicationMenuImpl applicationMenu = new ApplicationMenuImpl("firstMenu", 11L, 14L, 1); given(applicationAPI.getApplicationMenu(1L)).willReturn(applicationMenu); given(converter.toApplicationMenuItem(applicationMenu)).willReturn(new ApplicationMenuItem()); final ApplicationMenuItem createdItem = dataStore.get(APIID.makeAPIID(1L)); assertThat(createdItem).isEqualTo(itemToCreate); }
@Test(expected = APIException.class) public void should_throw_APIException_when_the_engine_throw_NotFoundException_on_get() throws Exception { given(applicationAPI.getApplicationMenu(1)).willThrow(new ApplicationMenuNotFoundException("")); dataStore.get(APIID.makeAPIID("1")); } |
### Question:
ApplicationMenuDataStore extends CommonDatastore<ApplicationMenuItem, ApplicationMenu> implements DatastoreHasAdd<ApplicationMenuItem>,
DatastoreHasUpdate<ApplicationMenuItem>,
DatastoreHasGet<ApplicationMenuItem>, DatastoreHasSearch<ApplicationMenuItem>, DatastoreHasDelete { @Override public void delete(final List<APIID> ids) { try { for (final APIID id : ids) { applicationAPI.deleteApplicationMenu(id.toLong()); } } catch (final Exception e) { throw new APIException(e); } } ApplicationMenuDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final ApplicationMenuItemConverter converter); @Override ApplicationMenuItem add(final ApplicationMenuItem item); @Override ApplicationMenuItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationMenuItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationMenuItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_delete_the_good_Application_Page_on_delete() throws Exception { dataStore.delete(Arrays.<APIID> asList(APIID.makeAPIID("1"), APIID.makeAPIID("2"))); verify(applicationAPI, times(1)).deleteApplicationMenu(1); verify(applicationAPI, times(1)).deleteApplicationMenu(2); }
@Test(expected = APIException.class) public void should_throw_APIException_on_delete_when_engine_throws_exception() throws Exception { doThrow(new DeletionException("")).when(applicationAPI).deleteApplicationMenu(1); dataStore.delete(Arrays.<APIID> asList(APIID.makeAPIID("1"))); } |
### Question:
ApplicationMenuDataStore extends CommonDatastore<ApplicationMenuItem, ApplicationMenu> implements DatastoreHasAdd<ApplicationMenuItem>,
DatastoreHasUpdate<ApplicationMenuItem>,
DatastoreHasGet<ApplicationMenuItem>, DatastoreHasSearch<ApplicationMenuItem>, DatastoreHasDelete { @Override public ItemSearchResult<ApplicationMenuItem> search(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { final SearchOptionsCreator creator = makeSearchOptionCreator(page, resultsByPage, search, orders, filters); try { final SearchResult<ApplicationMenu> searchResult = runSearch(creator); final List<ApplicationMenuItem> appMenuItems = convertEngineToConsoleItemsList(searchResult.getResult()); return new ItemSearchResult<ApplicationMenuItem>(page, resultsByPage, searchResult.getCount(), appMenuItems); } catch (final SearchException e) { throw new APIException(e); } } ApplicationMenuDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final ApplicationMenuItemConverter converter); @Override ApplicationMenuItem add(final ApplicationMenuItem item); @Override ApplicationMenuItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationMenuItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationMenuItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test(expected = APIException.class) public void should_throw_APIException_when_engine_throws_SearchException_on_search() throws Exception { final String orders = ApplicationMenuItem.ATTRIBUTE_DISPLAY_NAME + " DESC"; given(applicationAPI.searchApplicationMenus(any(SearchOptions.class))).willThrow(new SearchException(null)); dataStore.search(0, 1, null, orders, Collections.<String, String> emptyMap()); } |
### Question:
TenantAdminDatastore extends Datastore implements DatastoreHasUpdate<TenantAdminItem>, DatastoreHasGet<TenantAdminItem> { @Override public TenantAdminItem get(final APIID id) { final TenantAdminItem tenantAdminItem = new TenantAdminItem(); try { final boolean tenantPaused = getTenantManagementEngineClient().isTenantPaused(); tenantAdminItem.setIsPaused(tenantPaused); tenantAdminItem.setId(apiSession.getTenantId()); return tenantAdminItem; } catch (final Exception e) { throw new APIException(e); } } TenantAdminDatastore(final APISession apiSession); @Override TenantAdminItem update(final APIID unusedId, final Map<String, String> attributes); @Override TenantAdminItem get(final APIID id); }### Answer:
@Test public void testGetTenantAvailable() throws Exception { when(tenantAdministrationAPI.isPaused()).thenReturn(false); final APIID apiid = APIID.makeAPIID(1L); final TenantAdminItem tenantAdminItem = tenantAdminDatastore.get(apiid); verify(tenantAdministrationAPI, times(1)).isPaused(); verify(tenantAdministrationAPI, times(0)).resume(); verify(tenantAdministrationAPI, times(0)).pause(); assertFalse(tenantAdminItem.isPaused()); }
@Test public void testGetTenantInMaintenance() throws Exception { when(tenantAdministrationAPI.isPaused()).thenReturn(true); final APIID apiid = APIID.makeAPIID(1L); final TenantAdminItem tenantAdminItem = tenantAdminDatastore.get(apiid); verify(tenantAdministrationAPI, times(1)).isPaused(); verify(tenantAdministrationAPI, times(0)).resume(); verify(tenantAdministrationAPI, times(0)).pause(); assertTrue(tenantAdminItem.isPaused()); } |
### Question:
GetProfileHelper implements DatastoreHasGet<ProfileItem> { @Override public ProfileItem get(APIID id) { Profile profile = profileClient.getProfile(id.toLong()); return new ProfileItemConverter().convert(profile); } GetProfileHelper(ProfileEngineClient profileClient); @Override ProfileItem get(APIID id); }### Answer:
@Test public void testWeCanRetrieveAProfile() throws Exception { final Profile aKnownProfile = anEngineProfile().withName("aName").withDescription("aDescription").build(); when(profileClient.getProfile(1L)).thenReturn(aKnownProfile); final ProfileItem item = getProfileHelper.get(APIID.makeAPIID(1L)); assertTrue(areEquals(aProfileItem().fromEngineItem(aKnownProfile).withIcon(ProfileItemConverter.DEFAULT_PROFILE_ICONPATH).build(), item)); } |
### Question:
ProfileFilterCreator extends GenericFilterCreator { @Override public Filter<? extends Serializable> create(String attribute, String value) { if (ProfileItem.FILTER_HAS_NAVIGATION.equals(attribute)) { return Boolean.valueOf(value) ? new Filter<String>(new Field(attribute, fieldConverter), null, Operator.DIFFERENT_FROM) : new Filter<String>(new Field(attribute, fieldConverter), null); } return super.create(attribute, value); } ProfileFilterCreator(AttributeConverter fieldConverter); @Override Filter<? extends Serializable> create(String attribute, String value); }### Answer:
@Test public void should_create_a_filter_for_profiles_with_navigation() { ProfileFilterCreator profileFilterCreator = new ProfileFilterCreator(new ProfileSearchDescriptorConverter()); Filter<? extends Serializable> filter = profileFilterCreator.create(ProfileItem.FILTER_HAS_NAVIGATION, "true"); assertThat(filter.getField()).isEqualTo(ProfileSearchDescriptor.PROFILE_ENTRY_NAME); assertThat(filter.getValue()).isNull(); assertThat(filter.getOperator()).isEqualTo(Operator.DIFFERENT_FROM); }
@Test public void should_create_a_filter_for_profiles_without_navigation() { ProfileFilterCreator profileFilterCreator = new ProfileFilterCreator(new ProfileSearchDescriptorConverter()); Filter<? extends Serializable> filter = profileFilterCreator.create(ProfileItem.FILTER_HAS_NAVIGATION, "false"); assertThat(filter.getField()).isEqualTo(ProfileSearchDescriptor.PROFILE_ENTRY_NAME); assertThat(filter.getValue()).isNull(); assertThat(filter.getOperator()).isEqualTo(Operator.EQUAL); } |
### Question:
PageLister { public List<BonitaPageItem> getPages() { return pages; } List<BonitaPageItem> getPages(); BonitaPageItem getPage(final String token); List<BonitaPageItem> getPages(final List<String> pagesTokenToSkip); }### Answer:
@Test public void getPages_return_all_available_bonita_pages() { final List<BonitaPageItem> pages = pageLister.getPages(); assertThat(pages, equalTo(PageLister.pages)); }
@Test public void getPages_return_all_pages_not_in_pagesToSkip_list() throws Exception { final BonitaPageItem pageToSkip1 = PageLister.pages.get(0); final BonitaPageItem pageToSkip2 = PageLister.pages.get(1); final List<BonitaPageItem> expectedPages = buildExpectedPagesList(pageToSkip1, pageToSkip2); final List<String> pagesTokenToSkip = asList(pageToSkip1.getToken(), pageToSkip2.getToken()); final List<BonitaPageItem> pages = pageLister.getPages(pagesTokenToSkip); assertThat(pages, equalTo(expectedPages)); } |
### Question:
ProfileSearchDescriptorConverter implements AttributeConverter { @Override public String convert(String attribute) { String descriptor = mapping.get(attribute); if (descriptor == null) { throw new RuntimeException(attribute + " has no valid search descriptor"); } return descriptor; } @Override String convert(String attribute); @Override Map<String, TYPE> getValueTypeMapping(); }### Answer:
@Test public void testWeCanConvertTheProfileId() throws Exception { String descriptor = new ProfileSearchDescriptorConverter().convert(ProfileItem.ATTRIBUTE_ID); assertEquals(ProfileSearchDescriptor.ID, descriptor); }
@Test public void testWeCanConvertTheProfileName() throws Exception { String descriptor = new ProfileSearchDescriptorConverter().convert(ProfileItem.ATTRIBUTE_NAME); assertEquals(ProfileSearchDescriptor.NAME, descriptor); }
@Test public void testWeCanConvertHasNavigation() throws Exception { String descriptor = new ProfileSearchDescriptorConverter().convert(ProfileItem.FILTER_HAS_NAVIGATION); assertEquals(ProfileSearchDescriptor.PROFILE_ENTRY_NAME, descriptor); }
@Test(expected = RuntimeException.class) public void testTryingToConvertUnexistingDescriptorThrowAnException() { new ProfileSearchDescriptorConverter().convert("someUnsupportedAttribute"); } |
### Question:
ProfileEntryItemConverter extends ItemConverter<ProfileEntryItem, ProfileEntry> { @Override public ProfileEntryItem convert(ProfileEntry profileEntry) { ProfileEntryItem item = new ProfileEntryItem(); item.setId(profileEntry.getId()); item.setName(profileEntry.getName()); item.setProfileId(profileEntry.getProfileId()); item.setIndex(profileEntry.getIndex()); item.setType(profileEntry.getType()); item.setDescription(profileEntry.getDescription()); item.setParentId(profileEntry.getParentId()); item.setPage(profileEntry.getPage()); item.setIsCustom(profileEntry.isCustom()); if (item.isCustom() && profileEntry.getParentId() != 0) { item.setIcon(ProfileEntryItem.DEFAULT_ICON_BLACK); } else if (item.isCustom() && profileEntry.getParentId() == 0) { item.setIcon(ProfileEntryItem.DEFAULT_ICON_WHITE); } else { item.setIcon(""); } return item; } @Override ProfileEntryItem convert(ProfileEntry profileEntry); }### Answer:
@Test public void testWeCanConverteAProfileEntry() throws Exception { ProfileEntry profileEntry = anEngineProfileEntry().withCustomName("customName").build(); ProfileEntryItem item = new ProfileEntryItemConverter().convert(profileEntry); assertTrue(areEquals(aProfileEntryItem().from(profileEntry).build(), item)); } |
### Question:
GetProfileEntryHelper implements DatastoreHasGet<ProfileEntryItem> { @Override public ProfileEntryItem get(APIID id) { ProfileEntry profileEntry = profileEntryClient.getProfileEntry(id.toLong()); return new ProfileEntryItemConverter().convert(profileEntry); } GetProfileEntryHelper(ProfileEntryEngineClient profileEntryClient); @Override ProfileEntryItem get(APIID id); }### Answer:
@Test public void testWeCanRetrieveAProfileEntry() throws Exception { ProfileEntry expectedProfileEntry = anEngineProfileEntry().build(); when(profileEntryClient.getProfileEntry(1L)).thenReturn(expectedProfileEntry); ProfileEntryItem item = getProfileEntryHelper.get(APIID.makeAPIID(1L)); assertTrue(areEquals(aProfileEntryItem().from(expectedProfileEntry).build(), item)); } |
### Question:
SearchProfileEntriesHelper implements DatastoreHasSearch<ProfileEntryItem> { @Override public ItemSearchResult<ProfileEntryItem> search(int page, int resultsByPage, String search, String orders, Map<String, String> filters) { SearchOptionsCreator options = makeSearchOptions(page, resultsByPage, search, orders, filters); SearchResult<ProfileEntry> profileEntries = profileEntryClient.searchProfiles(options.create()); return new ItemSearchResultConverter<ProfileEntryItem, ProfileEntry>(page, resultsByPage, profileEntries, new ProfileEntryItemConverter()).toItemSearchResult(); } SearchProfileEntriesHelper(ProfileEntryEngineClient profileEntryClient); @Override ItemSearchResult<ProfileEntryItem> search(int page, int resultsByPage, String search, String orders, Map<String, String> filters); }### Answer:
@Test public void testWeCanSearchProfiles() throws Exception { SearchResult<ProfileEntry> aKnownSearchResult = SearchUtils.createEngineSearchResult(aKnownProfileEntry(), anotherKnownProfileEntry()); List<ProfileEntryItem> expectedProfileEntryItems = new ProfileEntryItemConverter().convert(aKnownSearchResult.getResult()); when(profileEntryClient.searchProfiles(any(SearchOptions.class))).thenReturn(aKnownSearchResult); ItemSearchResult<ProfileEntryItem> searchResult = searchProfileEntriesHelper.search(0, 10, null, null, null); assertTrue(SearchUtils.areEquals(expectedProfileEntryItems, searchResult.getResults())); } |
### Question:
ProfileEntrySearchDescriptorConverter implements AttributeConverter { @Override public String convert(String attribute) { return MapUtil.getMandatory(mapping, attribute); } ProfileEntrySearchDescriptorConverter(); @Override String convert(String attribute); @Override Map<String, TYPE> getValueTypeMapping(); }### Answer:
@Test public void testWeCanConvertTheProfileEntryId() throws Exception { String descriptor = new ProfileEntrySearchDescriptorConverter() .convert(ProfileEntryItem.ATTRIBUTE_ID); assertEquals(ProfileEntrySearchDescriptor.ID, descriptor); }
@Test public void testWeCanConvertTheProfileEntryIndex() throws Exception { String descriptor = new ProfileEntrySearchDescriptorConverter() .convert(ProfileEntryItem.ATTRIBUTE_INDEX); assertEquals(ProfileEntrySearchDescriptor.INDEX, descriptor); }
@Test public void testWeCanConvertTheProfileEntryName() throws Exception { String descriptor = new ProfileEntrySearchDescriptorConverter() .convert(ProfileEntryItem.ATTRIBUTE_NAME); assertEquals(ProfileEntrySearchDescriptor.NAME, descriptor); }
@Test public void testWeCanConvertTheProfileEntryProfileId() throws Exception { String descriptor = new ProfileEntrySearchDescriptorConverter() .convert(ProfileEntryItem.ATTRIBUTE_PARENT_ID); assertEquals(ProfileEntrySearchDescriptor.PARENT_ID, descriptor); }
@Test public void testWeCanConvertTheProfileEntryParentId() throws Exception { String descriptor = new ProfileEntrySearchDescriptorConverter() .convert(ProfileEntryItem.ATTRIBUTE_PROFILE_ID); assertEquals(ProfileEntrySearchDescriptor.PROFILE_ID, descriptor); }
@Test(expected = RuntimeException.class) public void testTryingToConvertUnexistingDescriptorThrowAnException() { new ProfileSearchDescriptorConverter().convert("someUnsupportedAttribute"); } |
### Question:
ProfileItemConverter extends ItemConverter<ProfileItem, Profile> { @Override public ProfileItem convert(final Profile profile) { final ProfileItem item = new ProfileItem(); item.setId(profile.getId()); item.setName(profile.getName()); item.setDescription(profile.getDescription()); item.setIsDefault(profile.isDefault()); item.setIcon(getIconPath(profile.getName())); item.setUpdatedByUserId(profile.getLastUpdatedBy()); item.setLastUpdateDate(profile.getLastUpdateDate()); item.setCreatedByUserId(profile.getCreatedBy()); item.setCreationDate(profile.getCreationDate()); return item; } @Override ProfileItem convert(final Profile profile); static final String USER_PROFILE_NAME; static final String ADMIN_PROFILE_NAME; static final String PROCESSMANAGER_PROFILE_NAME; static final String TEAMMANAGER_PROFILE_NAME; static final String USER_PROFILE_ICONPATH; static final String ADMIN_PROFILE_ICONPATH; static final String PROCESSMANAGER_PROFILE_ICONPATH; static final String TEAMMANAGER_PROFILE_ICONPATH; static final String DEFAULT_PROFILE_ICONPATH; }### Answer:
@Test public void testProfileItemConvertion() { final Profile profile = anEngineProfile().withName("aName").withDescription("aDescription").build(); final ProfileItem item = new ProfileItemConverter().convert(profile); assertTrue(areEquals(aProfileItem().fromEngineItem(profile).withIcon(ProfileItemConverter.DEFAULT_PROFILE_ICONPATH).build(), item)); } |
### Question:
MemberTypeConverter implements ValueConverter<MemberType> { @Override public MemberType convert(String value) { return MemberType.from(value); } @Override MemberType convert(String value); }### Answer:
@Test public void testMemberTypeConversion() throws Exception { MemberTypeConverter converter = new MemberTypeConverter(); MemberType value = converter.convert(AbstractMemberItem.VALUE_MEMBER_TYPE_ROLE); assertEquals(MemberType.ROLE, value); } |
### Question:
AddProfileMemberHelper implements DatastoreHasAdd<ProfileMemberItem> { @Override public ProfileMemberItem add(ProfileMemberItem item) { ProfileMember addedProfileMember = addProfileMember(item.getProfileId(), item.getUserId(), item.getGroupId(), item.getRoleId()); return new ProfileMemberItemConverter().convert(addedProfileMember); } AddProfileMemberHelper(ProfileMemberEngineClient engineClient); @Override ProfileMemberItem add(ProfileMemberItem item); }### Answer:
@Test public void testWeCanCreateAMembershipForAUSer() { ProfileMember aKnownProfile = anEngineProfileMember().build(); when(engineClient.createProfileMember(1L, 2L, null, null)).thenReturn(aKnownProfile); ProfileMemberItem item = aProfileMemberItem().withProfileId(1L).withUserId(2L).withGroupId(null) .withRoleId(null).build(); ProfileMemberItem newItem = addProfileHelper.add(item); assertTrue(areEquals(aProfileMemberItem().from(aKnownProfile).build(), newItem)); } |
### Question:
SearchProfileMembersHelper implements DatastoreHasSearch<ProfileMemberItem> { @Override public ItemSearchResult<ProfileMemberItem> search(int page, int resultsByPage, String search, String orders, Map<String, String> filters) { SearchOptionsCreator options = makeSearchOptions(page, resultsByPage, search, orders, filters); SearchResult<ProfileMember> searchResult = profileMemberClient.searchProfileMembers(getMemberType(filters).getType(), options.create()); return new ItemSearchResultConverter<ProfileMemberItem, ProfileMember>(page, resultsByPage, searchResult, new ProfileMemberItemConverter()).toItemSearchResult(); } SearchProfileMembersHelper(ProfileMemberEngineClient profileMemberClient); @Override ItemSearchResult<ProfileMemberItem> search(int page, int resultsByPage, String search, String orders, Map<String, String> filters); }### Answer:
@Test public void testWeCanSearchProfileMembers() throws Exception { SearchResultImpl<ProfileMember> aKnownSearchResult = aKnownSearchResult(); List<ProfileMemberItem> expectedProfileMemberItems = new ProfileMemberItemConverter().convert(aKnownSearchResult().getResult()); when(engineClient.searchProfileMembers(eq(MemberType.ROLE.getType()), any(SearchOptions.class))).thenReturn(aKnownSearchResult); HashMap<String, String> filters = filterOnProfileIdAndMemberType(5L, MemberType.ROLE); ItemSearchResult<ProfileMemberItem> searchResult = searchProfilesHelper.search(0, 10, null, null, filters); assertTrue(SearchUtils.areEquals(expectedProfileMemberItems, searchResult.getResults())); }
@Test(expected = APIFilterMandatoryException.class) public void testSearchWithoutMandatoryFiltersThrowError() { searchProfilesHelper.search(0, 10, null, null, Collections.<String, String> emptyMap()); } |
### Question:
ProfileMemberItemConverter extends ItemConverter<ProfileMemberItem, ProfileMember> { @Override public ProfileMemberItem convert(ProfileMember profileMember) { ProfileMemberItem item = new ProfileMemberItem(); item.setId(profileMember.getId()); item.setProfileId(profileMember.getProfileId()); item.setUserId(profileMember.getUserId()); item.setRoleId(profileMember.getRoleId()); item.setGroupId(profileMember.getGroupId()); return item; } @Override ProfileMemberItem convert(ProfileMember profileMember); }### Answer:
@Test public void testProfileMemberItemConversion() { ProfileMemberItemConverter converter = new ProfileMemberItemConverter(); ProfileMember profileMember = anEngineProfileMember().build(); ProfileMemberItem item = converter.convert(profileMember); assertTrue(areEquals(aProfileMemberItem().from(profileMember).build(), item)); } |
### Question:
ApplicationPageSearchDescriptorConverter implements AttributeConverter { @Override public String convert(final String attribute) { return MapUtil.getMandatory(mapping, attribute); } ApplicationPageSearchDescriptorConverter(); @Override String convert(final String attribute); @Override Map<String, ItemAttribute.TYPE> getValueTypeMapping(); }### Answer:
@Test public void should_return_ApplicationPageSearchDescriptor_id_on_convert_attribute_id() throws Exception { final String convertedValue = converter.convert(ApplicationPageItem.ATTRIBUTE_ID); assertThat(convertedValue).isEqualTo(ApplicationPageSearchDescriptor.ID); }
@Test public void should_return_ApplicationPageSearchDescriptor_name_on_convert_attribute_name() throws Exception { final String convertedValue = converter.convert(ApplicationPageItem.ATTRIBUTE_TOKEN); assertThat(convertedValue).isEqualTo(ApplicationPageSearchDescriptor.TOKEN); }
@Test public void should_return_ApplicationPageSearchDescriptor_applicationId_on_convert_attribute_applicationId() throws Exception { final String convertedValue = converter.convert(ApplicationPageItem.ATTRIBUTE_APPLICATION_ID); assertThat(convertedValue).isEqualTo(ApplicationPageSearchDescriptor.APPLICATION_ID); }
@Test public void should_return_ApplicationPageSearchDescriptor_pageId_on_convert_attribute_pageId() throws Exception { final String convertedValue = converter.convert(ApplicationPageItem.ATTRIBUTE_PAGE_ID); assertThat(convertedValue).isEqualTo(ApplicationPageSearchDescriptor.PAGE_ID); } |
### Question:
ApplicationPageDataStore extends CommonDatastore<ApplicationPageItem, ApplicationPage> implements DatastoreHasAdd<ApplicationPageItem>,
DatastoreHasGet<ApplicationPageItem>, DatastoreHasSearch<ApplicationPageItem>, DatastoreHasDelete { @Override public ApplicationPageItem add(final ApplicationPageItem item) { try { final ApplicationPage applicationPage = applicationAPI.createApplicationPage(item.getApplicationId().toLong(), item.getPageId().toLong(), item.getToken()); return converter.toApplicationPageItem(applicationPage); } catch (final Exception e) { throw new APIException(e); } } ApplicationPageDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI,
final ApplicationPageItemConverter converter); @Override ApplicationPageItem add(final ApplicationPageItem item); @Override ApplicationPageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationPageItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_return_result_of_engine_call_converted_to_item_on_add() throws Exception { final ApplicationPageItem itemToCreate = new ApplicationPageItem(); itemToCreate.setToken("firstPage"); itemToCreate.setApplicationId(14L); itemToCreate.setPageId(28L); final ApplicationPageImpl applicationPage = new ApplicationPageImpl(14L, 28L, "firstPage"); given(applicationAPI.createApplicationPage(14L, 28L, "firstPage")).willReturn(applicationPage); final ApplicationPageItem createdItem = dataStore.add(itemToCreate); assertThat(createdItem).isEqualTo(createdItem); }
@Test(expected = APIException.class) public void should_throw_APIException_when_engine_throws_CreationException_on_add() throws Exception { given(applicationAPI.createApplicationPage(anyLong(), anyLong(), anyString())).willThrow(new CreationException("")); dataStore.add(new ApplicationPageItem()); } |
### Question:
ApplicationPageDataStore extends CommonDatastore<ApplicationPageItem, ApplicationPage> implements DatastoreHasAdd<ApplicationPageItem>,
DatastoreHasGet<ApplicationPageItem>, DatastoreHasSearch<ApplicationPageItem>, DatastoreHasDelete { @Override public ApplicationPageItem get(final APIID id) { try { final ApplicationPage applicationPage = applicationAPI.getApplicationPage(id.toLong()); return converter.toApplicationPageItem(applicationPage); } catch (final Exception e) { throw new APIException(e); } } ApplicationPageDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI,
final ApplicationPageItemConverter converter); @Override ApplicationPageItem add(final ApplicationPageItem item); @Override ApplicationPageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationPageItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_return_the_applicationPage_supplied_by_the_engine_converted_to_item_on_get() throws Exception { final ApplicationPage applicationPage = mock(ApplicationPage.class); final ApplicationPageItem item = mock(ApplicationPageItem.class); given(applicationAPI.getApplicationPage(1)).willReturn(applicationPage); given(converter.toApplicationPageItem(applicationPage)).willReturn(item); final ApplicationPageItem retrivedItem = dataStore.get(APIID.makeAPIID("1")); assertThat(retrivedItem).isNotNull(); assertThat(retrivedItem).isEqualTo(item); }
@Test(expected = APIException.class) public void should_throw_APIException_when_the_engine_throw_NotFoundException_on_get() throws Exception { given(applicationAPI.getApplicationPage(1)).willThrow(new ApplicationPageNotFoundException("")); dataStore.get(APIID.makeAPIID("1")); } |
### Question:
ApplicationPageDataStore extends CommonDatastore<ApplicationPageItem, ApplicationPage> implements DatastoreHasAdd<ApplicationPageItem>,
DatastoreHasGet<ApplicationPageItem>, DatastoreHasSearch<ApplicationPageItem>, DatastoreHasDelete { @Override public void delete(final List<APIID> ids) { try { for (final APIID id : ids) { applicationAPI.deleteApplicationPage(id.toLong()); } } catch (final Exception e) { throw new APIException(e); } } ApplicationPageDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI,
final ApplicationPageItemConverter converter); @Override ApplicationPageItem add(final ApplicationPageItem item); @Override ApplicationPageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationPageItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void should_delete_the_good_Application_Page_on_delete() throws Exception { dataStore.delete(Arrays.<APIID> asList(APIID.makeAPIID("1"), APIID.makeAPIID("2"))); verify(applicationAPI, times(1)).deleteApplicationPage(1); verify(applicationAPI, times(1)).deleteApplicationPage(2); }
@Test(expected = APIException.class) public void should_throw_APIException_on_delete_when_engine_throws_exception() throws Exception { doThrow(new DeletionException("")).when(applicationAPI).deleteApplicationPage(1); dataStore.delete(Arrays.<APIID> asList(APIID.makeAPIID("1"))); } |
### Question:
ApplicationPageDataStore extends CommonDatastore<ApplicationPageItem, ApplicationPage> implements DatastoreHasAdd<ApplicationPageItem>,
DatastoreHasGet<ApplicationPageItem>, DatastoreHasSearch<ApplicationPageItem>, DatastoreHasDelete { @Override public ItemSearchResult<ApplicationPageItem> search(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { final SearchOptionsCreator creator = makeSearchOptionCreator(page, resultsByPage, search, orders, filters); try { final SearchResult<ApplicationPage> searchResult = runSearch(creator); final List<ApplicationPageItem> appPageItems = convertEngineToConsoleItemsList(searchResult.getResult()); return new ItemSearchResult<ApplicationPageItem>(page, resultsByPage, searchResult.getCount(), appPageItems); } catch (final SearchException e) { throw new APIException(e); } } ApplicationPageDataStore(final APISession engineSession, final ApplicationAPI applicationAPI, final PageAPI pageAPI,
final ApplicationPageItemConverter converter); @Override ApplicationPageItem add(final ApplicationPageItem item); @Override ApplicationPageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationPageItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test(expected = APIException.class) public void should_throw_APIException_when_engine_throws_SearchException_on_search() throws Exception { final String orders = ApplicationPageItem.ATTRIBUTE_TOKEN + " DESC"; given(applicationAPI.searchApplicationPages(any(SearchOptions.class))).willThrow(new SearchException(null)); dataStore.search(0, 1, null, orders, Collections.<String, String> emptyMap()); } |
### Question:
Sorts { public List<Sort> asList() { return sorts; } Sorts(String orders, AttributeConverter converter); Sorts(String orders); List<Sort> asList(); }### Answer:
@Test public void testNullSortListing() throws Exception { Sorts sorts = new Sorts(null); List<Sort> sortList = sorts.asList(); Assert.assertTrue(sortList.isEmpty()); }
@Test public void testEmptySortListing() throws Exception { Sorts sorts = new Sorts(""); List<Sort> sortList = sorts.asList(); Assert.assertTrue(sortList.isEmpty()); }
@Test public void testSingleSortListing() throws Exception { Sorts sorts = new Sorts("attribute " + Order.ASC); List<Sort> sortList = sorts.asList(); Assert.assertEquals(new Sort("attribute " + Order.ASC), sortList.get(0)); }
@Test public void testMultipleSortListing() throws Exception { String attribute1Order = "attribute1 " + Order.ASC; String attribute2Order = "attribute2 " + Order.DESC; Sorts sorts = new Sorts(attribute1Order + "," + attribute2Order); List<Sort> sortList = sorts.asList(); Assert.assertEquals(new Sort(attribute1Order), sortList.get(0)); Assert.assertEquals(new Sort(attribute2Order), sortList.get(1)); } |
### Question:
VariableMapper { public Serializable getSerializableValue(String className) { try { return (Serializable) deserializer.convertValue(variable.getValue(), Class.forName(className)); } catch (IllegalArgumentException e) { throw new APIException(new _("%value% is not a valid value for %className%", new Arg("value", variable.getValue()), new Arg("className", className))); } catch (ClassNotFoundException e) { throw new APIException(new _("%className% not found. Only jdk types are supported", new Arg("className", className))); } catch (ClassCastException e) { throw new APIException(new _("%className% is not Serializable", new Arg("className", className))); } } VariableMapper(Variable variable, JacksonDeserializer jacksonDeserializer); Serializable getSerializableValue(String className); String getName(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test(expected = APIException.class) public void getSerializableValue_throw_exception_if_class_is_not_in_classpath() throws Exception { new VariableMapper(new Variable(), jacksonDeserializer).getSerializableValue("a.class.not.in.classpath"); } |
### Question:
Sort { @Override public String toString() { return new StringBuilder().append(getField()) .append(SEPARATOR) .append(getOrder()).toString(); } Sort(String sortValue, AttributeConverter converter); Sort(String sortValue); String getField(); Order getOrder(); @Override String toString(); @Override boolean equals(Object obj); static final Order DEFAULT_ORDER; }### Answer:
@Test public void testToStringForParamWithConvertionValue() { Sort sort = new Sort( ActivityItem.ATTRIBUTE_ROOT_CASE_ID + " " + Order.DESC, new ActivityAttributeConverter()); Assert.assertEquals(sort.toString(), ActivityInstanceSearchDescriptor.PROCESS_INSTANCE_ID + " " + Order.DESC); }
@Test public void testToStringForParamWithoutConvertionValue() { Sort sort = new Sort( "TestParam " + Order.DESC, new ActivityAttributeConverter()); Assert.assertEquals(sort.toString(), "TestParam " + Order.DESC); } |
### Question:
ArchivedCaseDocumentDatastore extends CommonDatastore<ArchivedCaseDocumentItem, ArchivedDocument> implements DatastoreHasGet<CaseDocumentItem>,
DatastoreHasDelete { @Override public ArchivedCaseDocumentItem get(final APIID id) { try { final ArchivedDocument documentItem = processAPI.getArchivedProcessDocument(id.toLong()); return convertEngineToConsoleItem(documentItem); } catch (final Exception e) { throw new APIException(e); } } ArchivedCaseDocumentDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue, final ProcessAPI processAPI); @Override ArchivedCaseDocumentItem get(final APIID id); ItemSearchResult<ArchivedCaseDocumentItem> search(final int page, final int resultsByPage,
final String search, final Map<String, String> filters, final String orders); @Override void delete(final List<APIID> ids); }### Answer:
@Test public void it_should_call_engine_processAPI_getDocument() throws Exception { final APIID id = APIID.makeAPIID(1l); documentDatastore.get(id); verify(processAPI).getArchivedProcessDocument(id.toLong()); }
@Test(expected = APIException.class) public void it_should_catch_and_throw_APIException_for_not_find_document() throws Exception { final APIID id = APIID.makeAPIID(1l); when(processAPI.getArchivedProcessDocument(id.toLong())).thenThrow(new ArchivedDocumentNotFoundException(new Exception())); documentDatastore.get(id); } |
### Question:
ArchivedCaseDocumentDatastore extends CommonDatastore<ArchivedCaseDocumentItem, ArchivedDocument> implements DatastoreHasGet<CaseDocumentItem>,
DatastoreHasDelete { @Override protected ArchivedCaseDocumentItem convertEngineToConsoleItem(final ArchivedDocument item) { if (item != null) { return new ArchivedCaseDocumentItemConverter().convert(item); } return null; } ArchivedCaseDocumentDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue, final ProcessAPI processAPI); @Override ArchivedCaseDocumentItem get(final APIID id); ItemSearchResult<ArchivedCaseDocumentItem> search(final int page, final int resultsByPage,
final String search, final Map<String, String> filters, final String orders); @Override void delete(final List<APIID> ids); }### Answer:
@Test public void it_should_convert_item_return_item() throws Exception { final ArchivedCaseDocumentItem convertedEngineToConsoleItem = documentDatastore.convertEngineToConsoleItem(mockedDocument); assertTrue(convertedEngineToConsoleItem != null); }
@Test public void it_should_not_convert_null_item_return_null() { final CaseDocumentItem convertedEngineToConsoleItem = documentDatastore.convertEngineToConsoleItem(null); assertTrue(convertedEngineToConsoleItem == null); } |
### Question:
CaseDocumentDatastore extends CommonDatastore<CaseDocumentItem, Document> implements DatastoreHasAdd<CaseDocumentItem>,
DatastoreHasGet<CaseDocumentItem>,
DatastoreHasUpdate<CaseDocumentItem>, DatastoreHasDelete { @Override public CaseDocumentItem get(final APIID id) { try { final Document documentItem = processAPI.getDocument(id.toLong()); return convertEngineToConsoleItem(documentItem); } catch (final Exception e) { throw new APIException(e); } } CaseDocumentDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue, final ProcessAPI processAPI,
final BonitaHomeFolderAccessor tenantFolder); @Override CaseDocumentItem get(final APIID id); @Override CaseDocumentItem add(final CaseDocumentItem item); @Override CaseDocumentItem update(final APIID id, final Map<String, String> attributes); ItemSearchResult<CaseDocumentItem> search(final int page, final int resultsByPage,
final String search, final Map<String, String> filters, final String orders); @Override void delete(final List<APIID> ids); }### Answer:
@Test public void it_should_call_engine_processAPI_getDocument() throws Exception { final APIID id = APIID.makeAPIID(1l); documentDatastore.get(id); verify(processAPI).getDocument(id.toLong()); }
@Test(expected = APIException.class) public void it_should_catch_and_throw_APIException_for_not_find_document() throws Exception { final APIID id = APIID.makeAPIID(1l); when(processAPI.getDocument(id.toLong())).thenThrow(new DocumentNotFoundException("not found", new Exception())); documentDatastore.get(id); } |
### Question:
CaseDocumentDatastore extends CommonDatastore<CaseDocumentItem, Document> implements DatastoreHasAdd<CaseDocumentItem>,
DatastoreHasGet<CaseDocumentItem>,
DatastoreHasUpdate<CaseDocumentItem>, DatastoreHasDelete { @Override protected CaseDocumentItem convertEngineToConsoleItem(final Document item) { if (item != null) { return new CaseDocumentItemConverter().convert(item); } return null; } CaseDocumentDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue, final ProcessAPI processAPI,
final BonitaHomeFolderAccessor tenantFolder); @Override CaseDocumentItem get(final APIID id); @Override CaseDocumentItem add(final CaseDocumentItem item); @Override CaseDocumentItem update(final APIID id, final Map<String, String> attributes); ItemSearchResult<CaseDocumentItem> search(final int page, final int resultsByPage,
final String search, final Map<String, String> filters, final String orders); @Override void delete(final List<APIID> ids); }### Answer:
@Test public void it_should_convert_item_return_item() throws Exception { final CaseDocumentItem convertedEngineToConsoleItem = documentDatastore.convertEngineToConsoleItem(mockedDocument); assertTrue(convertedEngineToConsoleItem != null); }
@Test public void it_should_not_convert_null_item_return_null() { final CaseDocumentItem convertedEngineToConsoleItem = documentDatastore.convertEngineToConsoleItem(null); assertTrue(convertedEngineToConsoleItem == null); } |
### Question:
CaseVariableDatastore extends CommonDatastore<CaseVariableItem, DataInstance> implements DatastoreHasSearch<CaseVariableItem>, DatastoreHasUpdate<CaseVariableItem> { public void updateVariableValue(final long caseId, final String variableName, final String className, final String newValue) { try { final Serializable converteValue = converter.convert(className, newValue); getEngineProcessAPI().updateProcessDataInstance(variableName, caseId, converteValue); } catch (final Exception e) { throw new APIException("Error when updating case variable", e); } } CaseVariableDatastore(final APISession engineSession); @Override CaseVariableItem update(final APIID id, final Map<String, String> attributes); @Override ItemSearchResult<CaseVariableItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); void updateVariableValue(final long caseId, final String variableName, final String className, final String newValue); ItemSearchResult<CaseVariableItem> findByCaseId(final long caseId, final int page, final int resultsByPage); CaseVariableItem findById(final long caseId, final String variableName); }### Answer:
@Test public void testUpdateVariableValue() throws Exception { long caseId = 1L; String name = "aName"; String newValue = "newValue"; datastore.updateVariableValue(caseId, name, String.class.getName(), newValue); verify(processAPI).updateProcessDataInstance(name, caseId, newValue); } |
### Question:
CaseDatastore extends CommonDatastore<CaseItem, ProcessInstance> implements DatastoreHasGet<CaseItem>, DatastoreHasSearch<CaseItem>,
DatastoreHasDelete, DatastoreHasAdd<CaseItem> { void addCallerFilterToSearchBuilderIfNecessary(final Map<String, String> filters, final SearchOptionsBuilder builder) { if (!filters.containsKey(CaseItem.FILTER_CALLER)) { builder.filter(ProcessInstanceSearchDescriptor.CALLER_ID, -1); } else if (!"any".equalsIgnoreCase(filters.get(CaseItem.FILTER_CALLER))) { builder.filter(ProcessInstanceSearchDescriptor.CALLER_ID, MapUtil.getValueAsLong(filters, CaseItem.FILTER_CALLER)); } } CaseDatastore(final APISession engineSession); long count(final String search, final String orders, final Map<String, String> filters); @Override ItemSearchResult<CaseItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override CaseItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override CaseItem add(final CaseItem caseItem); ProcessAPI getProcessAPI(); }### Answer:
@Test public final void addCallerFilterToSearchBuilderIfNecessary_should_do_nothing_when_filter_on_any_caller() { final Map<String, String> filters = Collections.singletonMap(CaseItem.FILTER_CALLER, "any"); final SearchOptionsBuilder builder = new SearchOptionsBuilder(0, 10); caseDatastore.addCallerFilterToSearchBuilderIfNecessary(filters, builder); assertTrue(builder.done().getFilters().isEmpty()); } |
### Question:
AbstractHumanTaskDatastore extends AbstractTaskDatastore<CONSOLE_ITEM, ENGINE_ITEM> { @Override protected SearchResult<ENGINE_ITEM> runSearch(final SearchOptionsBuilder builder, final Map<String, String> filters) { try { APIID id = null; id = APIID.makeAPIID(filters.get(HumanTaskItem.FILTER_SUPERVISOR_ID)); if (id != null) { filters.remove(HumanTaskItem.FILTER_SUPERVISOR_ID); return runSupervisorSearch(filters, builder, id.toLong()); } id = APIID.makeAPIID(filters.get(HumanTaskItem.FILTER_TEAM_MANAGER_ID)); if (id != null) { return runTeamManagerSearch(filters, builder, id.toLong()); } return runGenericSearch(builder, filters); } catch (final Exception e) { throw new APIException(e); } } AbstractHumanTaskDatastore(final APISession engineSession); @Override CONSOLE_ITEM get(final APIID id); @Override CONSOLE_ITEM update(final APIID id, final Map<String, String> attributes); Long getNumberOfOpenTasks(final APIID userId); Long getNumberOfOverdueOpenTasks(final APIID userId); }### Answer:
@Test public void should_use_searchAssignedAndPendingHumanTasks_when_filtering_ready_state() throws SearchException { datastore.runSearch(new SearchOptionsBuilder(1, 100), Collections.singletonMap("state", "ready")); verify(processAPI).searchAssignedAndPendingHumanTasks(any()); }
@Test public void should_use_searchHumanTaskInstances_when_there_is_no_particular_filter() throws SearchException { datastore.runSearch(new SearchOptionsBuilder(1, 100), Collections.singletonMap("tpye", "toto")); verify(processAPI).searchHumanTaskInstances(any()); } |
### Question:
ThemeArchive { public byte[] asByteArray() { checkZippedThemeIsSet(); return zippedTheme; } ThemeArchive(); ThemeArchive(byte[] zippedTheme); void setZippedTheme(byte[] zippedTheme); ThemeModifier extract(File themeDirectory); byte[] asByteArray(); }### Answer:
@Test public void should_return_zip_as_byte_array() throws Exception { final byte[] content = createStyleFiles("bonita.css"); final ThemeArchive themeArchive = new ThemeArchive(content); assertThat(themeArchive.asByteArray()).isEqualTo(content); } |
### Question:
ConnectorInstanceDatastore extends CommonDatastore<ConnectorInstanceItem, ConnectorInstance> implements DatastoreHasSearch<ConnectorInstanceItem> { protected SearchOptions buildSearchOptions(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { final SearchOptionsBuilder builder = SearchOptionsBuilderUtil.buildSearchOptions(page, resultsByPage, orders, search); addStringFilterToSearchBuilder(filters, builder, ConnectorInstanceItem.ATTRIBUTE_CONTAINER_ID, ConnectorInstancesSearchDescriptor.CONTAINER_ID); addStringFilterToSearchBuilder(filters, builder, ConnectorInstanceItem.ATTRIBUTE_STATE, ConnectorInstancesSearchDescriptor.STATE); return builder.done(); } ConnectorInstanceDatastore(final APISession engineSession); @Override ItemSearchResult<ConnectorInstanceItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void searchBuildRightParameters() throws Exception { final Map<String, String> filters = new HashMap<String, String>(); filters.put(ConnectorInstanceItem.ATTRIBUTE_CONTAINER_ID, "1"); filters.put(ConnectorInstanceItem.ATTRIBUTE_STATE, "2"); final SearchOptions searchOptions = this.spiedDatastore.buildSearchOptions(0, 123, "searchTerm", "order " + Order.ASC, filters); Assert.assertEquals(0, searchOptions.getStartIndex()); Assert.assertEquals(123, searchOptions.getMaxResults()); Assert.assertEquals("searchTerm", searchOptions.getSearchTerm()); Assert.assertEquals("order", searchOptions.getSorts().get(0).getField()); Assert.assertEquals(Order.ASC, searchOptions.getSorts().get(0).getOrder()); Assert.assertEquals(filters.size(), searchOptions.getFilters().size()); } |
### Question:
ProcessCategoryDatastore extends CommonDatastore<ProcessCategoryItem, Serializable> implements
DatastoreHasAdd<ProcessCategoryItem>,
DatastoreHasDelete { @Override public ProcessCategoryItem add(final ProcessCategoryItem item) { try { getProcessAPI().addCategoriesToProcess(item.getProcessId().toLong(), Arrays.asList(item.getCategoryId().toLong())); return item; } catch (AlreadyExistsException e) { throw new APIForbiddenException(new _("This category has already been added to this process"), e); } catch (final Exception e) { throw new APIException(e); } } ProcessCategoryDatastore(final APISession engineSession); @Override void delete(final List<APIID> ids); @Override ProcessCategoryItem add(final ProcessCategoryItem item); }### Answer:
@Test(expected = APIForbiddenException.class) public void addingTwiceSameCategoryOnProcessIsForbidden() throws Exception { ProcessCategoryItem processCategory = aProcessCategory().build(); doThrow(new AlreadyExistsException("this thing already exists!")).when(processAPI) .addCategoriesToProcess(processCategory.getProcessId().toLong(), asList(processCategory.getCategoryId().toLong())); processCategoryDatastore.add(processCategory); } |
### Question:
PermissionsBuilder { void addPagesOfProfile(final String profile, final Set<String> pageTokens) throws ProfileNotFoundException { final List<ProfileEntry> profileEntries = profileAPI.getProfileEntries(profile); for (final ProfileEntry profileEntry : profileEntries) { if (profileEntry.getType().equals(ProfileEntryItem.VALUE_TYPE.link.name())) { pageTokens.add(profileEntry.getPage()); } } } PermissionsBuilder(final APISession session, final ProfileAPI profileAPI,
final ApplicationAPI applicationAPI, final CustomPermissionsMapping customPermissionsMapping,
final CompoundPermissionsMapping compoundPermissionsMapping); Set<String> getPermissions(); static final String PROFILE_TYPE_AUTHORIZATION_PREFIX; static final String USER_TYPE_AUTHORIZATION_PREFIX; }### Answer:
@Test public void should_addPagesOfProfile_complete_set_of_page() throws Exception { final Set<String> pages = new HashSet<>(); doReturn(asList(profileEntryWithPage("page1"), profileEntryWithPage("page2"))).when(profileAPI).getProfileEntries("myProfile1"); doReturn(asList(profileEntryWithPage("page2"), profileEntryWithPage("page3"))).when(profileAPI).getProfileEntries("myProfile2"); permissionsBuilder.addPagesOfProfile("myProfile1", pages); permissionsBuilder.addPagesOfProfile("myProfile2", pages); assertThat(pages).containsOnly("page1", "page2", "page3"); } |
### Question:
CategoryDatastore extends CommonDatastore<CategoryItem, Category> implements
DatastoreHasSearch<CategoryItem>,
DatastoreHasGet<CategoryItem>,
DatastoreHasDelete,
DatastoreHasAdd<CategoryItem>,
DatastoreHasUpdate<CategoryItem> { @Override public CategoryItem add(final CategoryItem item) { try { final Category result = getProcessAPI().createCategory(item.getName(), item.getDescription()); return convertEngineToConsoleItem(result); } catch (final AlreadyExistsException e) { throw new APIForbiddenException(new _("Category with name %categoryName% already exists", new Arg("categoryName", item.getName())), e); } catch (final Exception e) { throw new APIException(e); } } CategoryDatastore(final APISession engineSession); long getNumberOfCategories(); long getNumberOfCategories(long processId); @Override ItemSearchResult<CategoryItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override CategoryItem add(final CategoryItem item); @Override CategoryItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override CategoryItem update(final APIID id, final Map<String, String> attributes); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = APIForbiddenException.class) public void addingTwiceSameCategoryIsForbidden() throws Exception { when(processAPI.createCategory(anyString(), anyString())).thenThrow(new AlreadyExistsException("category already exists")); categoryDatastore.add(aCategoryItem().build()); } |
### Question:
ProcessConnectorDatastore extends CommonDatastore<ProcessConnectorItem, ConnectorImplementationDescriptor> implements
DatastoreHasGet<ProcessConnectorItem>,
DatastoreHasSearch<ProcessConnectorItem> { @Override public ProcessConnectorItem get(final APIID id) { try { final ProcessConnectorItem connector = convertEngineToConsoleItem( getProcessAPI().getConnectorImplementation( id.getPartAsLong(ATTRIBUTE_PROCESS_ID), id.getPart(ATTRIBUTE_NAME), id.getPart(ATTRIBUTE_VERSION) )); connector.setProcessId(id.getPartAsLong(ATTRIBUTE_PROCESS_ID)); return connector; } catch (final Exception e) { throw new APIException(e); } } ProcessConnectorDatastore(final APISession engineSession); @Override ProcessConnectorItem get(final APIID id); @Override ItemSearchResult<ProcessConnectorItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void getRetrieveConnectorImplementationAndSetProcessId() throws Exception { final ConnectorImplementationDescriptor descriptor = aConnectorImplementationDescriptor("aName"); when(this.processAPI.getConnectorImplementation(1L, "name", "1")).thenReturn(descriptor); final ProcessConnectorItem fetchedItem = this.processConnectorDatastore.get(anAPIID("1", "name", "1")); final ProcessConnectorItem expectedItem = convertToItem(descriptor, "1"); assertTrue(areEquals(expectedItem, fetchedItem)); }
@Test(expected = APIException.class) public void getThrowExceptionIfProcessDefinitionIsNotFound() throws Exception { when(this.processAPI.getConnectorImplementation(anyLong(), anyString(), anyString())) .thenThrow(new ConnectorNotFoundException(null)); this.processConnectorDatastore.get(anAPIID("1", "name", "1")); } |
### Question:
ProcessConnectorDatastore extends CommonDatastore<ProcessConnectorItem, ConnectorImplementationDescriptor> implements
DatastoreHasGet<ProcessConnectorItem>,
DatastoreHasSearch<ProcessConnectorItem> { @Override public ItemSearchResult<ProcessConnectorItem> search(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { try { final Long processId = MapUtil.getValueAsLong(filters, ATTRIBUTE_PROCESS_ID); final List<ConnectorImplementationDescriptor> connectors = getProcessAPI().getConnectorImplementations( processId, SearchOptionsBuilderUtil.computeIndex(page, resultsByPage), resultsByPage, ConnectorCriterion.valueOf(orders.toUpperCase().replace(" ", "_"))); final List<ProcessConnectorItem> results = new ArrayList<ProcessConnectorItem>(); for (final ConnectorImplementationDescriptor connector : connectors) { final ProcessConnectorItem result = convertEngineToConsoleItem(connector); result.setProcessId(processId); results.add(result); } final long numtotalConnectorImplem = getProcessAPI().getNumberOfConnectorImplementations(processId); return new ItemSearchResult<ProcessConnectorItem>(page, resultsByPage, numtotalConnectorImplem, results); } catch (final Exception e) { throw new APIException(e); } } ProcessConnectorDatastore(final APISession engineSession); @Override ProcessConnectorItem get(final APIID id); @Override ItemSearchResult<ProcessConnectorItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test(expected = APIException.class) public void searchThrowExceptionIfProcessDefinitionIsNotFound() throws Exception { when(this.processAPI.getConnectorImplementations(anyLong(), anyInt(), anyInt(), any(ConnectorCriterion.class))) .thenThrow(new NullPointerException()); this.processConnectorDatastore.search(0, 10, null, null, aProcessIdFilter("1")); } |
### Question:
ProcessConnectorDatastore extends CommonDatastore<ProcessConnectorItem, ConnectorImplementationDescriptor> implements
DatastoreHasGet<ProcessConnectorItem>,
DatastoreHasSearch<ProcessConnectorItem> { @Override protected ProcessConnectorItem convertEngineToConsoleItem(final ConnectorImplementationDescriptor item) { final ProcessConnectorItem result = new ProcessConnectorItem(); result.setName(item.getDefinitionId()); result.setVersion(item.getDefinitionVersion()); result.setImplementationName(item.getId()); result.setImplementationVersion(item.getVersion()); result.setClassname(item.getImplementationClassName()); return result; } ProcessConnectorDatastore(final APISession engineSession); @Override ProcessConnectorItem get(final APIID id); @Override ItemSearchResult<ProcessConnectorItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); }### Answer:
@Test public void testConvertEngineToConsoleItem() throws Exception { final ConnectorImplementationDescriptor descriptor = new ConnectorImplementationDescriptor("implementationClassName", "name", "version", "definitionId", "definitionVersion", EMPTY_LIST); final ProcessConnectorItem expectedItem = new ProcessConnectorItem(); expectedItem.setName("definitionId"); expectedItem.setVersion("definitionVersion"); expectedItem.setImplementationName("name"); expectedItem.setImplementationVersion("version"); expectedItem.setClassname("implementationClassName"); final ProcessConnectorItem convertedItem = this.processConnectorDatastore.convertEngineToConsoleItem(descriptor); assertTrue(areEquals(expectedItem, convertedItem)); } |
### Question:
PermissionsBuilder { Set<String> getCustomPermissions(final String type, final String identifier) { final Set<String> profileSinglePermissions = new HashSet<>(); final Set<String> customPermissionsForEntity = getCustomPermissionsRaw(type, identifier); for (final String customPermissionForEntity : customPermissionsForEntity) { final Set<String> simplePermissions = getCompoundPermissions(customPermissionForEntity); if (!simplePermissions.isEmpty()) { profileSinglePermissions.addAll(simplePermissions); } else { profileSinglePermissions.add(customPermissionForEntity); } } return profileSinglePermissions; } PermissionsBuilder(final APISession session, final ProfileAPI profileAPI,
final ApplicationAPI applicationAPI, final CustomPermissionsMapping customPermissionsMapping,
final CompoundPermissionsMapping compoundPermissionsMapping); Set<String> getPermissions(); static final String PROFILE_TYPE_AUTHORIZATION_PREFIX; static final String USER_TYPE_AUTHORIZATION_PREFIX; }### Answer:
@Test public void should_getCustomPermissions_work_with_compound_permissions() { doReturn(aSet("Perm1", "Perm2", "taskListing")).when(customPermissionsMapping).getPropertyAsSet("user|myUser"); doReturn(aSet("Perm3", "Perm4")).when(compoundPermissionsMapping).getPropertyAsSet("taskListing"); final Set<String> permissions = permissionsBuilder.getCustomPermissions("user", "myUser"); assertThat(permissions).containsOnly("Perm1","Perm2","Perm3","Perm4"); } |
### Question:
StringValueConverter implements ValueConverter<String> { @Override public String convert(String value) { return value; } @Override String convert(String value); }### Answer:
@Test public void testStringConvertion() throws Exception { String value = new StringValueConverter().convert("cba"); assertEquals("cba", value); } |
### Question:
LongValueConverter implements ValueConverter<Long> { @Override public Long convert(String value) { return Long.valueOf(value); } @Override Long convert(String value); }### Answer:
@Test public void testLongValueConvertion() throws Exception { Long value = new LongValueConverter().convert("54"); assertEquals(Long.valueOf(54L), value); }
@Test(expected = NumberFormatException.class) public void testStringConvertionThrowsExceptio() throws Exception { new LongValueConverter().convert("abc"); } |
### Question:
UserDatastore extends CommonDatastore<UserItem, User> implements DatastoreHasGet<UserItem> { public UserItem update(final APIID id, final Map<String, String> attributes) { UserUpdater userUpdater = new UserUpdaterConverter().convert(attributes, getEngineSession().getTenantId(), getBonitaHomeFolderAccessor()); User user = getUserEngineClient().update(id.toLong(), userUpdater); return userItemConverter.convert(user); } UserDatastore(final APISession engineSession); UserItem add(final UserItem user); UserItem update(final APIID id, final Map<String, String> attributes); @Override UserItem get(final APIID id); ItemSearchResult<UserItem> search(final int page, final int resultsByPage, final String search,
final Map<String, String> filters, final String orders); void delete(final List<APIID> ids); }### Answer:
@Test public void should_updateUser_call_engine_api() throws Exception { doReturn(new UserImpl(12L, "john", "bpm")).when(identityAPI).updateUser(eq(12L), any(UserUpdater.class)); Map<String, String> attributes = new HashMap<>(); attributes.put("userName", "jack"); attributes.put("icon", ""); datastore.update(APIID.makeAPIID(12L), attributes); verify(identityAPI).updateUser(eq(12L), userUpdaterArgumentCaptor.capture()); UserUpdater userUpdater = userUpdaterArgumentCaptor.getValue(); assertThat(userUpdater.getFields()).containsOnly(entry(UserUpdater.UserField.USER_NAME, "jack")); } |
### Question:
PermissionsBuilder { void addPagesOfApplication(final String profile, final Set<String> pageTokens) { final List<String> allPagesForProfile = applicationAPI.getAllPagesForProfile(profile); pageTokens.addAll(allPagesForProfile); } PermissionsBuilder(final APISession session, final ProfileAPI profileAPI,
final ApplicationAPI applicationAPI, final CustomPermissionsMapping customPermissionsMapping,
final CompoundPermissionsMapping compoundPermissionsMapping); Set<String> getPermissions(); static final String PROFILE_TYPE_AUTHORIZATION_PREFIX; static final String USER_TYPE_AUTHORIZATION_PREFIX; }### Answer:
@Test public void testAddPagesOfApplication() { Set<String> permissions = aSet("Perm1", "Perm2"); doReturn(asList("Perm3", "Perm4")).when(applicationAPI).getAllPagesForProfile("myProfile1"); doReturn(asList("Perm4", "Perm5")).when(applicationAPI).getAllPagesForProfile("myProfile2"); permissionsBuilder.addPagesOfApplication("myProfile1", permissions); permissionsBuilder.addPagesOfApplication("myProfile2", permissions); assertThat(permissions).containsOnly("Perm1", "Perm2", "Perm3", "Perm4", "Perm5"); } |
### Question:
XMLExpressionsUtil extends XPathUtil { public Expression parseExpression(final Node expressionParentNode) throws InvalidFormDefinitionException { return parseExpression(NON_APPLICABLE_PREFIX, expressionParentNode); } protected XMLExpressionsUtil(); static synchronized XMLExpressionsUtil getInstance(); List<List<Expression>> parseExpressionsArray(final Node expressionsNode); List<List<Expression>> parseExpressionsArray(final String expressionParentName, final Node expressionsNode); List<Expression> parseExpressionsList(final Node expressionsNode); List<Expression> parseExpressionsList(final String expressionParentName, final Node expressionsNode); List<Expression> parseExpressionsDependenciesList(final Node dependenciesNode); Expression parseExpression(final Node expressionParentNode); Expression parseExpression(final String expressionParentName, final Node expressionParentNode); static String NON_APPLICABLE_PREFIX; }### Answer:
@Test public void should_parseExpression_do_not_modify_dependencies() throws Exception { XMLExpressionsUtil xmlExpressionsUtil = new XMLExpressionsUtil(); String expressionParentNodeName = "script"; String expressionTagName = "input-parameter"; String fileName = "formsWithExpressionDependencies.xml"; File xmlFile = new File(getClass().getClassLoader().getResource(fileName).toURI()); if(!xmlFile.exists()){ throw new IllegalStateException("Recource File missing:" + fileName); } DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); Document doc = dBuilder.parse(xmlFile); Node expressionParentNode = null; NodeList nodeList = doc.getElementsByTagName(expressionTagName); for (int i = 0; i < nodeList.getLength(); i++) { if(nodeList.item(i).getAttributes().getNamedItem("name").getNodeValue().equals(expressionParentNodeName)){ expressionParentNode = nodeList.item(i); } } assertNotNull("Cannot retrieve the Expression Node with name: "+ expressionParentNodeName , expressionParentNode); Expression generatedExpression = xmlExpressionsUtil.parseExpression(expressionParentNodeName, expressionParentNode); assertEquals("script:<pattern-expression>",generatedExpression.getName()); assertEquals(generatedExpression.getDependencies().get(0).getName(), "myId"); } |
### Question:
UserSearchAttributeConverter implements AttributeConverter { @Override public String convert(final String attribute) { return mapping.get(attribute); } @Override String convert(final String attribute); @Override Map<String, TYPE> getValueTypeMapping(); }### Answer:
@Test public void convertFistName() throws Exception { String convert = converter.convert(UserItem.ATTRIBUTE_FIRSTNAME); assertEquals(UserSearchDescriptor.FIRST_NAME, convert); }
@Test public void convertLastName() throws Exception { String convert = converter.convert(UserItem.ATTRIBUTE_LASTNAME); assertEquals(UserSearchDescriptor.LAST_NAME, convert); }
@Test public void convertUserName() throws Exception { String convert = converter.convert(UserItem.ATTRIBUTE_USERNAME); assertEquals(UserSearchDescriptor.USER_NAME, convert); }
@Test public void convertGroupId() throws Exception { String convert = converter.convert(UserItem.FILTER_GROUP_ID); assertEquals(UserSearchDescriptor.GROUP_ID, convert); }
@Test public void convertManagerId() throws Exception { String convert = converter.convert(UserItem.ATTRIBUTE_MANAGER_ID); assertEquals(UserSearchDescriptor.MANAGER_USER_ID, convert); }
@Test public void convertRoleId() throws Exception { String convert = converter.convert(UserItem.FILTER_ROLE_ID); assertEquals(UserSearchDescriptor.ROLE_ID, convert); } |
### Question:
PageDatastore extends CommonDatastore<PageItem, Page> implements DatastoreHasAdd<PageItem>, DatastoreHasUpdate<PageItem>,
DatastoreHasGet<PageItem>, DatastoreHasSearch<PageItem>, DatastoreHasDelete { @Override public PageItem get(final APIID id) { try { final Page pageItem = pageAPI.getPage(id.toLong()); return convertEngineToConsoleItem(pageItem); } catch (final Exception e) { throw new APIException(e); } } PageDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue,
final PageAPI pageAPI,
final CustomPageService customPageService,
final CompoundPermissionsMapping compoundPermissionsMapping,
final ResourcesPermissionsMapping resourcesPermissionsMapping,
final BonitaHomeFolderAccessor tenantFolder); @Override PageItem add(final PageItem pageItem); @Override PageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<PageItem> search(final int page, final int resultsByPage, final String search,
final String orders,
final Map<String, String> filters); @Override PageItem update(final APIID id, final Map<String, String> attributes); static final String UNMAPPED_ATTRIBUTE_ZIP_FILE; }### Answer:
@Test(expected = APIException.class) public void should_get_a_not_existing_page_rise_exception() throws Exception { deleteDir(pagesDir); when(pageAPI.getPage(1l)).thenThrow(new PageNotFoundException("newPage")); pageDatastore.get(makeAPIID(1l)); } |
### Question:
PageDatastore extends CommonDatastore<PageItem, Page> implements DatastoreHasAdd<PageItem>, DatastoreHasUpdate<PageItem>,
DatastoreHasGet<PageItem>, DatastoreHasSearch<PageItem>, DatastoreHasDelete { protected boolean isPageTokenValid(final String urlToken) { return urlToken.matches(PAGE_TOKEN_PREFIX + "\\p{Alnum}+"); } PageDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue,
final PageAPI pageAPI,
final CustomPageService customPageService,
final CompoundPermissionsMapping compoundPermissionsMapping,
final ResourcesPermissionsMapping resourcesPermissionsMapping,
final BonitaHomeFolderAccessor tenantFolder); @Override PageItem add(final PageItem pageItem); @Override PageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<PageItem> search(final int page, final int resultsByPage, final String search,
final String orders,
final Map<String, String> filters); @Override PageItem update(final APIID id, final Map<String, String> attributes); static final String UNMAPPED_ATTRIBUTE_ZIP_FILE; }### Answer:
@Test public void should_IsPageTokenValid_returns_true_when_url_token_starts_with_custom_page_prefix() { assertThat(pageDatastore.isPageTokenValid(PageDatastore.PAGE_TOKEN_PREFIX + "anySuffix123456")).isTrue(); }
@Test public void should_IsPageTokenValid_returns_false_when_url_token_contains_non_alphanumeric_values() { assertThat(pageDatastore.isPageTokenValid(PageDatastore.PAGE_TOKEN_PREFIX + "suffixxx_dsqds")).isFalse(); }
@Test public void should_IsPageTokenValid_returns_false_when_url_token_does_not_starts_with_custom_page_prefix() { assertThat(pageDatastore.isPageTokenValid("WrongStartString" + PageDatastore.PAGE_TOKEN_PREFIX + "suffixx")).isFalse(); } |
### Question:
PageDatastore extends CommonDatastore<PageItem, Page> implements DatastoreHasAdd<PageItem>, DatastoreHasUpdate<PageItem>,
DatastoreHasGet<PageItem>, DatastoreHasSearch<PageItem>, DatastoreHasDelete { @Override protected PageItem convertEngineToConsoleItem(final Page item) { if (item != null) { return new PageItemConverter().convert(item); } return null; } PageDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue,
final PageAPI pageAPI,
final CustomPageService customPageService,
final CompoundPermissionsMapping compoundPermissionsMapping,
final ResourcesPermissionsMapping resourcesPermissionsMapping,
final BonitaHomeFolderAccessor tenantFolder); @Override PageItem add(final PageItem pageItem); @Override PageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<PageItem> search(final int page, final int resultsByPage, final String search,
final String orders,
final Map<String, String> filters); @Override PageItem update(final APIID id, final Map<String, String> attributes); static final String UNMAPPED_ATTRIBUTE_ZIP_FILE; }### Answer:
@Test public void should_ConvertEngineToConsoleItem_returns_null_if_item_is_null() { assertThat(pageDatastore.convertEngineToConsoleItem(null)).isNull(); }
@Test public void should_ConvertEngineToConsoleItem_return_null_when_null_page_is_given() { final Page nullPage = null; final PageItem testPageItem = pageDatastore.convertEngineToConsoleItem(nullPage); assertThat(testPageItem).isNull(); }
@Test public void should_ConvertEngineToConsoleItem_return_a_page_item_when_page_is_given() { final PageItem testPageItem = pageDatastore.convertEngineToConsoleItem(mockedPage); assertThat(testPageItem).isNotNull(); } |
### Question:
PageDatastore extends CommonDatastore<PageItem, Page> implements DatastoreHasAdd<PageItem>, DatastoreHasUpdate<PageItem>,
DatastoreHasGet<PageItem>, DatastoreHasSearch<PageItem>, DatastoreHasDelete { protected List<Long> APIIdsToLong(final List<APIID> ids) { final List<Long> result = new ArrayList<>(ids.size()); for (final APIID id : ids) { result.add(id.toLong()); } return result; } PageDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue,
final PageAPI pageAPI,
final CustomPageService customPageService,
final CompoundPermissionsMapping compoundPermissionsMapping,
final ResourcesPermissionsMapping resourcesPermissionsMapping,
final BonitaHomeFolderAccessor tenantFolder); @Override PageItem add(final PageItem pageItem); @Override PageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<PageItem> search(final int page, final int resultsByPage, final String search,
final String orders,
final Map<String, String> filters); @Override PageItem update(final APIID id, final Map<String, String> attributes); static final String UNMAPPED_ATTRIBUTE_ZIP_FILE; }### Answer:
@Test public void testAPIIdsToLong() { final APIID id1 = makeAPIID("1"); final APIID id2 = makeAPIID("2"); final List<APIID> listId = Arrays.asList(id1, id2); assertThat(pageDatastore.APIIdsToLong(listId)).isEqualTo(Arrays.asList(1L, 2L)); } |
### Question:
PageDatastore extends CommonDatastore<PageItem, Page> implements DatastoreHasAdd<PageItem>, DatastoreHasUpdate<PageItem>,
DatastoreHasGet<PageItem>, DatastoreHasSearch<PageItem>, DatastoreHasDelete { protected SearchResult<Page> runSearch(final Map<String, String> filters, final SearchOptionsCreator creator) throws SearchException { return pageAPI.searchPages(creator.create()); } PageDatastore(final APISession engineSession, final WebBonitaConstantsUtils constantsValue,
final PageAPI pageAPI,
final CustomPageService customPageService,
final CompoundPermissionsMapping compoundPermissionsMapping,
final ResourcesPermissionsMapping resourcesPermissionsMapping,
final BonitaHomeFolderAccessor tenantFolder); @Override PageItem add(final PageItem pageItem); @Override PageItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<PageItem> search(final int page, final int resultsByPage, final String search,
final String orders,
final Map<String, String> filters); @Override PageItem update(final APIID id, final Map<String, String> attributes); static final String UNMAPPED_ATTRIBUTE_ZIP_FILE; }### Answer:
@Test public void testRunSearch() throws Exception { final SearchOptionsCreator creator = new SearchOptionsCreator(0, 1, null, new Sorts(null), new Filters(null)); pageDatastore.runSearch(null, creator); verify(pageAPI, times(1)).searchPages(creator.create()); } |
### Question:
BonitaHomeFolderAccessor { public boolean isInTempFolder(final File file, final WebBonitaConstantsUtils webBonitaConstantsUtils) throws IOException { return isInFolder(file, webBonitaConstantsUtils.getTempFolder()); } BonitaHomeFolderAccessor(); File getTempFile(final String filePath, final Long tenantId); String getCompleteTempFilePath(final String filePath); String getCompleteTempFilePath(final String filePath, final Long tenantId); WebBonitaConstantsUtils getBonitaConstantUtil(final Long tenantId); boolean isInTempFolder(final File file, final WebBonitaConstantsUtils webBonitaConstantsUtils); boolean isInFolder(final File file, final File parentFolder); IconDescriptor getIconFromFileSystem(String iconPath, long tenantId); }### Answer:
@Test public void should_authorized_a_file_in_temp_folder() throws Exception { given(webBonitaConstantsUtils.getTempFolder()).willReturn(new File("." + File.separator + "tempFolder")); final File file = new File(webBonitaConstantsUtils.getTempFolder().getAbsolutePath(), "" + File.separator + ".." + File.separator + "tempFolder" + File.separator + "fileName.txt"); final boolean isInTempFolder = tenantFolder.isInTempFolder(file, webBonitaConstantsUtils); assertTrue(isInTempFolder); }
@Test public void should_unauthorized_a_file_not_in_temp_folder() throws Exception { given(webBonitaConstantsUtils.getTempFolder()).willReturn(new File("." + File.separator + "tempFolder")); final File file = new File(webBonitaConstantsUtils.getTempFolder().getAbsolutePath(), "" + File.separator + ".." + File.separator + ".." + File.separator + ".." + File.separator + "fileName.txt"); final boolean isInTempFolder = tenantFolder.isInTempFolder(file, webBonitaConstantsUtils); assertFalse(isInTempFolder); } |
### Question:
ProfileEntryEngineClient { public ProfileEntry getProfileEntry(final Long id) { try { return profileApi.getProfileEntry(id); } catch (final InvalidSessionException e) { throw new APIException(e); } catch (final ProfileEntryNotFoundException e) { throw new APIItemNotFoundException(ProfileEntryDefinition.TOKEN, APIID.makeAPIID(id)); } } protected ProfileEntryEngineClient(final ProfileAPI profileApi); ProfileEntry getProfileEntry(final Long id); SearchResult<ProfileEntry> searchProfiles(final SearchOptions options); List<ProfileEntry> getProfileEntriesByProfile(final Long profileId); List<ProfileEntry> getAllChildsOfAProfileEntry(final Long id); }### Answer:
@Test public void getProfileEntryItem_call_engine_and_get_profile_entry_with_specific_id() throws ProfileEntryNotFoundException { engineClient.getProfileEntry(1L); verify(profileAPI).getProfileEntry(1L); }
@Test(expected = APIItemNotFoundException.class) public void getProfileEntryItem_call_engine_and_if_profile_entry_not_found_raises_ProfileEntryException() throws APIItemNotFoundException, ProfileEntryNotFoundException { doThrow(new APIItemNotFoundException("profile entry not found", APIID.makeAPIID(-1L))).when(profileAPI).getProfileEntry(-1L); engineClient.getProfileEntry(-1L); } |
### Question:
ProfileEntryEngineClient { public SearchResult<ProfileEntry> searchProfiles(final SearchOptions options) { try { return profileApi.searchProfileEntries(options); } catch (final InvalidSessionException e) { throw new APISessionInvalidException(e); } catch (final SearchException e) { throw new APIException(e); } } protected ProfileEntryEngineClient(final ProfileAPI profileApi); ProfileEntry getProfileEntry(final Long id); SearchResult<ProfileEntry> searchProfiles(final SearchOptions options); List<ProfileEntry> getProfileEntriesByProfile(final Long profileId); List<ProfileEntry> getAllChildsOfAProfileEntry(final Long id); }### Answer:
@Test public void searchProfileEntries_call_engine_and_get_specific_results() throws SearchException { SearchOptions searchOptions = new SearchOptionsBuilder(0, 10).done(); engineClient.searchProfiles(searchOptions); verify(profileAPI).searchProfileEntries(searchOptions); }
@Test(expected = APIException.class) public void searchProfileEntries_call_engine_and_raise_Search_Exception_because_of_invalid_options() throws SearchException { SearchOptions searchOptions = new SearchOptionsBuilder(-1, 10).done(); doThrow(new APIException("Search options invalid")).when(profileAPI).searchProfileEntries(searchOptions); engineClient.searchProfiles(searchOptions); } |
### Question:
ActivityEngineClient { public DataInstance getDataInstance(String dataName, long activityId) { try { return processAPI.getActivityDataInstance(dataName, activityId); } catch (DataNotFoundException e) { throw new APIException(new _("Unable to find data instance %dataName% for activity %activityId%", new Arg("dataName", dataName), new Arg("activityId", activityId)), e); } } ActivityEngineClient(ProcessAPI processAPI); long countFailedActivities(); DataInstance getDataInstance(String dataName, long activityId); void updateVariables(long activityId, HashMap<String, Serializable> variables); }### Answer:
@Test(expected = APIException.class) public void getDataInstance_throw_exception_if_data_is_not_found() throws Exception { when(processAPI.getActivityDataInstance(anyString(), anyLong())).thenThrow(new DataNotFoundException(new NullPointerException())); activityEngineClient.getDataInstance("aName", 1L); } |
### Question:
UserEngineClient { public User update(long userId, UserUpdater userUpdater) { try { return identityAPI.updateUser(userId, userUpdater); } catch (UserNotFoundException e) { throw new APIException(new _("Can't update user. User not found"), e); } catch (UpdateException e) { throw new APIException(new _("Error when updating user"), e); } } UserEngineClient(IdentityAPI identityAPI); User update(long userId, UserUpdater userUpdater); User create(UserCreator creator); User get(long userId); void delete(List<Long> userIds); SearchResult<User> search(SearchOptions searchOptions); List<User> getUsersInGroup(long groupId, int startIndex, int maxResults); }### Answer:
@Test public void update_update_a_user_in_engine_repository() throws Exception { UserUpdater userUpdater = new UserUpdater(); userEngineClient.update(1L, userUpdater); verify(identityAPI).updateUser(1L, userUpdater); }
@Test(expected = APIException.class) public void update_throw_APIException_if_user_is_not_found_in_engine_repository() throws Exception { UserUpdater userUpdater = new UserUpdater(); when(identityAPI.updateUser(1L, userUpdater)).thenThrow(new UserNotFoundException("aMessage")); userEngineClient.update(1L, userUpdater); }
@Test(expected = APIException.class) public void update_throw_APIException_if_exception_occur_when_updating_user_in_engine_repository() throws Exception { UserUpdater userUpdater = new UserUpdater(); when(identityAPI.updateUser(1L, userUpdater)).thenThrow(new UpdateException("aMessage")); userEngineClient.update(1L, userUpdater); } |
### Question:
UserEngineClient { public User create(UserCreator creator) { try { return identityAPI.createUser(creator); } catch (AlreadyExistsException e) { throw new APIForbiddenException(new _("Can't create user. User '%userName%' already exists", new Arg("userName", creator.getFields().get(UserField.NAME))), e); } catch (CreationException e) { throw new APIException(new _("Error when creating user"), e); } } UserEngineClient(IdentityAPI identityAPI); User update(long userId, UserUpdater userUpdater); User create(UserCreator creator); User get(long userId); void delete(List<Long> userIds); SearchResult<User> search(SearchOptions searchOptions); List<User> getUsersInGroup(long groupId, int startIndex, int maxResults); }### Answer:
@Test public void create_create_a_user_in_engine_repository() throws Exception { UserCreator userCreator = new UserCreator("aName", "aPassword"); userEngineClient.create(userCreator); verify(identityAPI).createUser(userCreator); }
@Test(expected = APIException.class) public void create_throw_APIException_if_exception_occur_when_creating_user_in_engine_repository() throws Exception { UserCreator userCreator = new UserCreator("aName", "aPassword"); when(identityAPI.createUser(userCreator)).thenThrow(new CreationException("aMessage")); userEngineClient.create(userCreator); } |
### Question:
UserEngineClient { public User get(long userId) { try { return identityAPI.getUser(userId); } catch (UserNotFoundException e) { throw new APIException(new _("User not found"), e); } } UserEngineClient(IdentityAPI identityAPI); User update(long userId, UserUpdater userUpdater); User create(UserCreator creator); User get(long userId); void delete(List<Long> userIds); SearchResult<User> search(SearchOptions searchOptions); List<User> getUsersInGroup(long groupId, int startIndex, int maxResults); }### Answer:
@Test public void get_fetch_a_user_from_engine_repository() throws Exception { userEngineClient.get(1L); verify(identityAPI).getUser(1L); }
@Test(expected = APIException.class) public void get_throw_APIException_if_user_is_not_found_in_engine_repository() throws Exception { when(identityAPI.getUser(1L)).thenThrow(new UserNotFoundException("aMessage")); userEngineClient.get(1L); } |
### Question:
UserEngineClient { public void delete(List<Long> userIds) { try { identityAPI.deleteUsers(userIds); } catch (DeletionException e) { throw new APIException(new _("Error when deleting users"), e); } } UserEngineClient(IdentityAPI identityAPI); User update(long userId, UserUpdater userUpdater); User create(UserCreator creator); User get(long userId); void delete(List<Long> userIds); SearchResult<User> search(SearchOptions searchOptions); List<User> getUsersInGroup(long groupId, int startIndex, int maxResults); }### Answer:
@Test public void delete_delete_users_in_engine_repository() throws Exception { List<Long> idsToBeDeleted = asList(1L, 2L); userEngineClient.delete(idsToBeDeleted); verify(identityAPI).deleteUsers(idsToBeDeleted); }
@Test(expected = APIException.class) public void delete_throw_APIException_if_exception_occur_when_deleting_users_in_engine_repository() throws Exception { List<Long> idsToBeDeleted = asList(1L, 2L); doThrow(new DeletionException("aMessage")).when(identityAPI).deleteUsers(idsToBeDeleted); userEngineClient.delete(idsToBeDeleted); } |
### Question:
CustomUserInfoEngineClient { public CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator) { try { return identity.createCustomUserInfoDefinition(creator); } catch (CreationException e) { throw new APIException(new _("An error occurred while creating a definition"), e); } } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_create_a_given_definition() throws Exception { given(engine.createCustomUserInfoDefinition(any(CustomUserInfoDefinitionCreator.class))) .willReturn(new EngineCustomUserInfoDefinition(1L, "foo", "bar")); CustomUserInfoDefinition definition = client.createDefinition(new CustomUserInfoDefinitionCreator("foo")); assertThat(definition.getName()).isEqualTo("foo"); }
@Test(expected = APIException.class) public void should_fail_to_create_a_given_definition_when_engine_throw_an_exception() throws Exception { given(engine.createCustomUserInfoDefinition(any(CustomUserInfoDefinitionCreator.class))) .willThrow(new CreationException("failure")); client.createDefinition(new CustomUserInfoDefinitionCreator("foo")); } |
### Question:
BonitaHomeFolderAccessor { public boolean isInFolder(final File file, final File parentFolder) throws IOException { try { verifyFolderAuthorization(file, parentFolder); } catch (final UnauthorizedFolderException e) { return false; } return true; } BonitaHomeFolderAccessor(); File getTempFile(final String filePath, final Long tenantId); String getCompleteTempFilePath(final String filePath); String getCompleteTempFilePath(final String filePath, final Long tenantId); WebBonitaConstantsUtils getBonitaConstantUtil(final Long tenantId); boolean isInTempFolder(final File file, final WebBonitaConstantsUtils webBonitaConstantsUtils); boolean isInFolder(final File file, final File parentFolder); IconDescriptor getIconFromFileSystem(String iconPath, long tenantId); }### Answer:
@Test public void should_authorized_a_file_in_a_specific_folder() throws Exception { final File folder = new File("." + File.separator + "anyFolder"); final File file = new File("." + File.separator + "anyFolder" + File.separator + ".." + File.separator + "anyFolder" + File.separator + "fileName.txt"); final boolean isInTempFolder = tenantFolder.isInFolder(file, folder); assertTrue(isInTempFolder); }
@Test public void should_unauthorized_a_file_not_in_a_specific_folder() throws Exception { final File folder = new File("." + File.separator + "anyFolder"); final File file = new File("." + File.separator + "anyFolder" + File.separator + ".." + File.separator + ".." + File.separator + "fileName.txt"); final boolean isInTempFolder = tenantFolder.isInFolder(file, folder); assertFalse(isInTempFolder); } |
### Question:
CustomUserInfoEngineClient { public void deleteDefinition(long id) { try { identity.deleteCustomUserInfoDefinition(id); } catch (DeletionException e) { throw new APIException(new _("An error occurred while deleting an item with the id %id%", new Arg("id", id)), e); } } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_delete_a_given_definition() throws Exception { client.deleteDefinition(1L); verify(engine).deleteCustomUserInfoDefinition(1L); }
@Test(expected = APIException.class) public void should_fail_to_delete_a_given_definition_when_engine_throw_an_exception() throws Exception { willThrow(new DeletionException("failure")).given(engine) .deleteCustomUserInfoDefinition(1L); client.deleteDefinition(1L); } |
### Question:
CustomUserInfoEngineClient { public List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult) { return identity.getCustomUserInfoDefinitions(startIndex, maxResult); } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_list_definitions_for_a_given_range() throws Exception { given(engine.getCustomUserInfoDefinitions(0, 2)).willReturn(Arrays.<CustomUserInfoDefinition>asList( new EngineCustomUserInfoDefinition(1L), new EngineCustomUserInfoDefinition(2L))); List<CustomUserInfoDefinition> definitions = client.listDefinitions(0, 2); assertThat(definitions.get(0).getId()).isEqualTo(1L); assertThat(definitions.get(1).getId()).isEqualTo(2L); } |
### Question:
CustomUserInfoEngineClient { public long countDefinitions() { return identity.getNumberOfCustomInfoDefinitions(); } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_count_definitions() throws Exception { given(engine.getNumberOfCustomInfoDefinitions()).willReturn(5L); assertThat(client.countDefinitions()).isEqualTo(5); } |
### Question:
CustomUserInfoEngineClient { public List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult) { return identity.getCustomUserInfo(userId, startIndex, maxResult); } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_list_custom_information_for_a_given_user() { given(engine.getCustomUserInfo(1L, 0, 2)).willReturn(Arrays.asList( new CustomUserInfo(1L, new EngineCustomUserInfoDefinition(1L), new CustomUserInfoValueImpl()), new CustomUserInfo(1L, new EngineCustomUserInfoDefinition(2L), new CustomUserInfoValueImpl()))); List<CustomUserInfo> information = client.listCustomInformation(1L, 0, 2); assertThat(information.get(0).getDefinition().getId()).isEqualTo(1L); assertThat(information.get(1).getDefinition().getId()).isEqualTo(2L); } |
### Question:
CustomUserInfoEngineClient { public CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value) { try { return identity.setCustomUserInfoValue(definitionId, userId, value); } catch (UpdateException e) { throw new APIItemNotFoundException(org.bonitasoft.web.rest.model.identity.CustomUserInfoDefinition.TOKEN, APIID.makeAPIID(definitionId, userId)); } } CustomUserInfoEngineClient(IdentityAPI identity); CustomUserInfoDefinition createDefinition(CustomUserInfoDefinitionCreator creator); void deleteDefinition(long id); List<CustomUserInfoDefinition> listDefinitions(int startIndex, int maxResult); long countDefinitions(); List<CustomUserInfo> listCustomInformation(long userId, int startIndex, int maxResult); SearchResult<CustomUserInfoValue> searchCustomUserInfoValues(SearchOptions options); CustomUserInfoValue setCustomUserInfoValue(long definitionId, long userId, String value); }### Answer:
@Test public void should_the_value_of_a_given_custom_user_info() throws UpdateException { CustomUserInfoValueImpl value = new CustomUserInfoValueImpl(); value.setValue("foo"); given(engine.setCustomUserInfoValue(1L, 2L, "foo")).willReturn(value); CustomUserInfoValue foo = client.setCustomUserInfoValue(1L, 2L, "foo"); assertThat(foo.getValue()).isEqualTo("foo"); } |
### Question:
GroupEngineClient { public Group get(Long groupId) { try { return groupAPI.getGroup(groupId); } catch (GroupNotFoundException e) { throw new APIException(new _("Unable to find group %groupId%", new Arg("groupId", groupId))); } } protected GroupEngineClient(GroupAPI groupAPI); Group get(Long groupId); String getPath(String groupId); void delete(List<Long> groupIds); Group update(long groupId, GroupUpdater groupUpdater); Group create(GroupCreator groupCreator); }### Answer:
@Test public void get_get_a_group_in_engine_repository() throws Exception { groupEngineClient.get(1L); verify(groupAPI).getGroup(1L); }
@Test(expected = APIException.class) public void get_throw_APIException_if_group_is_not_found_in_engine_repository() throws Exception { when(groupAPI.getGroup(1L)).thenThrow(new GroupNotFoundException(new Exception())); groupEngineClient.get(1L); } |
### Question:
GroupEngineClient { public void delete(List<Long> groupIds) { try { groupAPI.deleteGroups(groupIds); } catch (DeletionException e) { throw new APIException(new _("Error when deleting groups"), e); } } protected GroupEngineClient(GroupAPI groupAPI); Group get(Long groupId); String getPath(String groupId); void delete(List<Long> groupIds); Group update(long groupId, GroupUpdater groupUpdater); Group create(GroupCreator groupCreator); }### Answer:
@Test public void delete_delete_groups_in_engine_repository() throws Exception { List<Long> groupIds = asList(1L, 2L); groupEngineClient.delete(groupIds); verify(groupAPI).deleteGroups(groupIds); }
@Test(expected = APIException.class) public void delete_throw_APIException_if_an_error_occurs_when_deleting_groups_in_engine_repository() throws Exception { List<Long> groupIds = asList(1L, 2L); doThrow(new DeletionException("error")).when(groupAPI).deleteGroups(groupIds); groupEngineClient.delete(groupIds); } |
### Question:
GroupEngineClient { public String getPath(String groupId) { try { return groupAPI.getGroup(parseId(groupId)).getPath(); } catch (GroupNotFoundException e) { throw new APIException(new _("Unable to get group path, group not found")); } } protected GroupEngineClient(GroupAPI groupAPI); Group get(Long groupId); String getPath(String groupId); void delete(List<Long> groupIds); Group update(long groupId, GroupUpdater groupUpdater); Group create(GroupCreator groupCreator); }### Answer:
@Test(expected = APIException.class) public void getPath_throw_APIexception_if_groupId_is_not_a_number() throws Exception { groupEngineClient.getPath("notANumber"); }
@Test public void getPath_return_the_group_path_for_the_specified_group_id() throws Exception { Group group = mock(Group.class); when(group.getPath()).thenReturn("/expected/group/path"); when(groupAPI.getGroup(1L)).thenReturn(group); String groupPath = groupEngineClient.getPath("1"); assertThat(groupPath, is("/expected/group/path")); } |
### Question:
GroupEngineClient { public Group create(GroupCreator groupCreator) { try { return groupAPI.createGroup(groupCreator); } catch (AlreadyExistsException e) { throw new APIException(new _( "Can't create group. Group '%groupName%' already exists", new Arg("groupName", groupCreator.getFields().get(GroupField.NAME)))); } catch (CreationException e) { throw new APIException(new _("Error when creating group"), e); } } protected GroupEngineClient(GroupAPI groupAPI); Group get(Long groupId); String getPath(String groupId); void delete(List<Long> groupIds); Group update(long groupId, GroupUpdater groupUpdater); Group create(GroupCreator groupCreator); }### Answer:
@Test public void create_create_a_group_in_engine_repository() throws Exception { GroupCreator creator = new GroupCreator("aName"); groupEngineClient.create(creator); verify(groupAPI).createGroup(creator); } |
### Question:
PermissionsBuilderAccessor { static void reloadPropertiesIfInDebug(SecurityProperties securityProperties, PlatformManagementUtils platformManagementUtils) throws LoginFailedException { if (securityProperties.isAPIAuthorizationsCheckInDebugMode()) { try { platformManagementUtils.initializePlatformConfiguration(); } catch (BonitaException | IOException e) { throw new LoginFailedException("Properties are in debug mode, unable to reload configuration", e); } } } static PermissionsBuilder createPermissionBuilder(final APISession session); }### Answer:
@Test public void should_reloadPropertiesIfInDebug_reload_properties_when_in_debug() throws Exception { doReturn(true).when(securityProperties).isAPIAuthorizationsCheckInDebugMode(); PermissionsBuilderAccessor.reloadPropertiesIfInDebug(securityProperties, platformManagementUtils); verify(platformManagementUtils).initializePlatformConfiguration(); }
@Test public void should_reloadPropertiesIfInDebug_do_not_reload_properties_when_not_in_debug() throws Exception { doReturn(false).when(securityProperties).isAPIAuthorizationsCheckInDebugMode(); PermissionsBuilderAccessor.reloadPropertiesIfInDebug(securityProperties, platformManagementUtils); verify(platformManagementUtils, never()).initializePlatformConfiguration(); }
@Test public void should_reloadPropertiesIfInDebug_handles_exception() throws Exception { doReturn(true).when(securityProperties).isAPIAuthorizationsCheckInDebugMode(); doThrow(IOException.class).when(platformManagementUtils).initializePlatformConfiguration(); expectedException.expect(LoginFailedException.class); expectedException.expectMessage("debug mode"); PermissionsBuilderAccessor.reloadPropertiesIfInDebug(securityProperties, platformManagementUtils); } |
### Question:
BusinessDataReferenceResourceFinder extends ResourceFinder { @Override public boolean handlesResource(Serializable object) { return object instanceof BusinessDataReference; } @Override ServerResource create(final Request request, final Response response); @Override boolean handlesResource(Serializable object); @Override Serializable toClientObject(Serializable object); }### Answer:
@Test public void should_handle_multiple_business_data() throws Exception { MultipleBusinessDataReferenceImpl bizDataRef = new MultipleBusinessDataReferenceImpl("Ticket", "com.acme.object.Ticket", Arrays.asList(7L, 8L)); boolean handlesResource = businessDataReferenceResourceFinder.handlesResource(bizDataRef); assertThat(handlesResource).isTrue(); }
@Test public void should_handle_simple_business_data() throws Exception { SimpleBusinessDataReferenceImpl bizDataRef = new SimpleBusinessDataReferenceImpl("Ticket", "com.acme.object.Ticket", 8L); boolean handlesResource = businessDataReferenceResourceFinder.handlesResource(bizDataRef); assertThat(handlesResource).isTrue(); }
@Test public void should_not_handle_other_types() throws Exception { boolean handlesResource = businessDataReferenceResourceFinder.handlesResource(12l); assertThat(handlesResource).isFalse(); } |
### Question:
BusinessDataReferencesResource extends CommonResource { @Get("json") public List<BusinessDataReference> getProcessBusinessDataReferences() { final Long processInstanceId = getCaseId(); final Integer p = getSearchPageNumber(); final Integer c = getSearchPageSize(); return bdmAPI.getProcessBusinessDataReferences(processInstanceId, p * c, c); } BusinessDataReferencesResource(final BusinessDataAPI bdmAPI); @Get("json") List<BusinessDataReference> getProcessBusinessDataReferences(); }### Answer:
@Test public void should_return_the_references_of_the_business_data_of_the_process_instance() throws Exception { final List<BusinessDataReference> references = new ArrayList<BusinessDataReference>(); references.add(buildSimpleEmployeeReference("john", 487467354L)); references.add(buildMultipleEmployeeReference("Ateam", 687646784L, 2313213874354L)); when(bdmAPI.getProcessBusinessDataReferences(486L, 10, 10)).thenReturn(references); final Response response = request("/bdm/businessDataReference?f=caseId%3D486&p=1&c=10").get(); assertThat(response).hasStatus(Status.SUCCESS_OK); assertThat(response).hasJsonEntityEqualTo(readFile("refs.json")); } |
### Question:
FormMappingItem implements Serializable { public String getPageId() { return pageId; } FormMappingItem(final FormMapping item); String getProcessDefinitionId(); void setProcessDefinitionId(final String processDefinitionId); String getPageMappingKey(); void setPageMappingKey(final String pageMappingKey); String getId(); void setId(final String id); String getTask(); void setTask(final String task); String getPageId(); void setPageId(final String pageId); String getURL(); void setPageURL(final String pageURL); FormMappingType getType(); void setType(final FormMappingType type); String getLastUpdatedBy(); void setLastUpdatedBy(final String lastUpdatedBy); Date getLastUpdateDate(); void setLastUpdateDate(final Date lastUpdateDate); FormMappingTarget getTarget(); void setTarget(final FormMappingTarget target); boolean isFormRequired(); void setFormRequired(final boolean formRequired); }### Answer:
@Test public void it_should_handle_a_null_pageId() { when(formMapping.getPageId()).thenReturn(null); FormMappingItem formMappingItem = new FormMappingItem(formMapping); assertThat(formMappingItem.getPageId()).isEqualTo(null); } |
### Question:
APIApplication extends ConsoleAPI<ApplicationItem> implements APIHasAdd<ApplicationItem>, APIHasSearch<ApplicationItem>,
APIHasGet<ApplicationItem>, APIHasUpdate<ApplicationItem>, APIHasDelete { @Override public ApplicationItem add(final ApplicationItem item) { return creator.create(getEngineSession()).add(item); } APIApplication(); APIApplication(final ApplicationDataStoreCreator creator, final APIApplicationDataStoreFactory applicationDataStoreFactory); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override String defineDefaultSearchOrder(); }### Answer:
@Test public void add_should_return_the_result_of_dataStore_add() throws Exception { final ApplicationItem itemToCreate = mock(ApplicationItem.class); final ApplicationItem createdItem = mock(ApplicationItem.class); given(dataStore.add(itemToCreate)).willReturn(createdItem); given(dataStore.add(itemToCreate)).willReturn(createdItem); final ApplicationItem retrievedItem = apiApplication.add(itemToCreate); assertThat(retrievedItem).isEqualTo(createdItem); } |
### Question:
APIApplication extends ConsoleAPI<ApplicationItem> implements APIHasAdd<ApplicationItem>, APIHasSearch<ApplicationItem>,
APIHasGet<ApplicationItem>, APIHasUpdate<ApplicationItem>, APIHasDelete { @Override public ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders, final Map<String, String> filters) { return creator.create(getEngineSession()).search(page, resultsByPage, search, orders, filters); } APIApplication(); APIApplication(final ApplicationDataStoreCreator creator, final APIApplicationDataStoreFactory applicationDataStoreFactory); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override String defineDefaultSearchOrder(); }### Answer:
@Test public void search_should_return_the_result_of_dataStore_search() throws Exception { @SuppressWarnings("unchecked") final ItemSearchResult<ApplicationItem> result = mock(ItemSearchResult.class); given(dataStore.search(0, 10, "request", "default", Collections.singletonMap("name", "hr"))).willReturn(result); final ItemSearchResult<ApplicationItem> retrievedResult = apiApplication.search(0, 10, "request", "default", Collections.singletonMap("name", "hr")); assertThat(retrievedResult).isEqualTo(result); } |
### Question:
APIApplication extends ConsoleAPI<ApplicationItem> implements APIHasAdd<ApplicationItem>, APIHasSearch<ApplicationItem>,
APIHasGet<ApplicationItem>, APIHasUpdate<ApplicationItem>, APIHasDelete { @Override public String defineDefaultSearchOrder() { return ApplicationItem.ATTRIBUTE_DISPLAY_NAME; } APIApplication(); APIApplication(final ApplicationDataStoreCreator creator, final APIApplicationDataStoreFactory applicationDataStoreFactory); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override String defineDefaultSearchOrder(); }### Answer:
@Test public void defineDefaultSearchOrder_should_return_attribute_name() throws Exception { final String defaultSearchOrder = apiApplication.defineDefaultSearchOrder(); assertThat(defaultSearchOrder).isEqualTo("displayName"); } |
### Question:
APIApplication extends ConsoleAPI<ApplicationItem> implements APIHasAdd<ApplicationItem>, APIHasSearch<ApplicationItem>,
APIHasGet<ApplicationItem>, APIHasUpdate<ApplicationItem>, APIHasDelete { @Override protected ItemDefinition<ApplicationItem> defineItemDefinition() { return ApplicationDefinition.get(); } APIApplication(); APIApplication(final ApplicationDataStoreCreator creator, final APIApplicationDataStoreFactory applicationDataStoreFactory); @Override ApplicationItem add(final ApplicationItem item); @Override ApplicationItem update(final APIID id, final Map<String, String> attributes); @Override ApplicationItem get(final APIID id); @Override void delete(final List<APIID> ids); @Override ItemSearchResult<ApplicationItem> search(final int page, final int resultsByPage, final String search, final String orders,
final Map<String, String> filters); @Override String defineDefaultSearchOrder(); }### Answer:
@Test public void defineItemDefinition_return_an_instance_of_ApplicationDefinition() throws Exception { final ItemDefinition<ApplicationItem> itemDefinition = apiApplication.defineItemDefinition(); assertThat(itemDefinition).isExactlyInstanceOf(ApplicationDefinition.class); } |
### Question:
ErrorMessage { public String getMessage() { return message; } ErrorMessage(); ErrorMessage(final Throwable t); String getException(); void setException(final String exception); String getMessage(); void setMessage(final String message); JacksonRepresentation<ErrorMessage> toEntity(); }### Answer:
@Test public void should_encode_message_when_using_constructor() throws Exception { ErrorMessage errorMessage = new ErrorMessage(new RuntimeException("<script>alert('bad')</script>")); assertThat(errorMessage.getMessage()).isEqualTo("\\u003cscript\\u003ealert(\\u0027bad\\u0027)\\u003c\\/script\\u003e"); } |
### Question:
CommonResource extends ServerResource { protected void verifyNotNullParameter(final Object parameter, final String parameterName) throws APIException { if (parameter == null) { throw new APIException("Parameter " + parameterName + " is mandatory."); } } APISession getEngineSession(); HttpSession getHttpSession(); HttpServletRequest getHttpRequest(); Integer getIntegerParameter(final String parameterName, final boolean mandatory); Long getLongParameter(final String parameterName, final boolean mandatory); String getParameter(final String parameterName, final boolean mandatory); List<String> getParameterAsList(final String name); SearchOptions buildSearchOptions(); @Override String getAttribute(final String name); Long getPathParamAsLong(final String parameterName); List<Long> getParameterAsLongList(final String parameterName); String getPathParam(final String name); }### Answer:
@Test(expected = APIException.class) public void nullMandatoryParameterIsForbidden() throws Exception { new CommonResource().verifyNotNullParameter(null, "unused"); }
@Test public void notNullMandatoryParameterIsForbidden() throws Exception { new CommonResource().verifyNotNullParameter(new Object(), "unused"); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.