Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: TimeoutConfiguration { @PostConstruct public void init() throws IOException { Properties prop = SearchUtils.loadProperties("/search_timeouts.properties"); stats = Integer.parseInt(prop.getProperty("stats", "2")); search = Integer.parseInt(prop.getProperty("search", "10")); ping = Integer.parseInt(prop.getProperty("ping", "10")); documentDetail = Integer.parseInt(prop.getProperty("documentDetail", "10")); documentReferencesCount = Integer.parseInt(prop.getProperty("documentReferencesCount", "10")); documentReferencesSearch = Integer.parseInt(prop.getProperty("documentReferencesSearch", "10")); subjectPatternCount = Integer.parseInt(prop.getProperty("subjectPatternCount", "10")); subjectPatternSearch = Integer.parseInt(prop.getProperty("subjectPatternSearch", "10")); } @PostConstruct void init(); int stats(); int search(); int ping(); int documentDetail(); int documentReferencesCount(); int documentReferencesSearch(); int subjectPatternCount(); int subjectPatternSearch(); }### Answer: @Test public void init() throws IOException { TimeoutConfiguration tested = new TimeoutConfiguration(); Assert.assertEquals(0, tested.stats()); Assert.assertEquals(0, tested.search()); Assert.assertEquals(0, tested.ping()); Assert.assertEquals(0, tested.documentDetail()); Assert.assertEquals(0, tested.documentReferencesCount()); Assert.assertEquals(0, tested.documentReferencesSearch()); Assert.assertEquals(0, tested.subjectPatternCount()); Assert.assertEquals(0, tested.subjectPatternSearch()); tested.init(); Assert.assertEquals(2, tested.stats()); Assert.assertEquals(3, tested.search()); Assert.assertEquals(4, tested.ping()); Assert.assertEquals(5, tested.documentDetail()); Assert.assertEquals(6, tested.documentReferencesCount()); Assert.assertEquals(7, tested.documentReferencesSearch()); Assert.assertEquals(8, tested.subjectPatternCount()); Assert.assertEquals(9, tested.subjectPatternSearch()); }
### Question: CORSWithCredentialsFilter implements Filter { @SuppressWarnings("unchecked") protected List<String> getConfigList(Map<String, Object> config, Object cfgKeyOrigins) { if (config != null) { try { List<String> l = (List<String>) config.get(cfgKeyOrigins); if (l == null \|\| l.isEmpty()) return null; return l; } catch (ClassCastException e) { log.warning("Invalid configuration in file " + ConfigService.CFGNAME_SECURITY_RESTAPI_CORS + " for key " + cfgKeyOrigins); } } return null; } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); @Override void destroy(); static final String OPTIONS; static final String GET; static final String POST; static final String PUT; static final String DELETE; static final String HEADER_ORIGIN; static final String ACCESS_CONTROL_ALLOW_ORIGIN; static final String ACCESS_CONTROL_ALLOW_CREDENTIALS; static final String ACCESS_CONTROL_ALLOW_HEADERS; static final String ACCESS_CONTROL_ALLOW_METHODS; static final String ACCESS_CONTROL_MAX_AGE; static final String ACCESS_CONTROL_ALLOW_HEADERS_VALUE; static final String ACCESS_CONTROL_MAX_AGE_VALUE; static final Object CFG_KEY_ORIGINS; static final Object CFG_KEY_ORIGINS_WITH_CREDENTIALS; }### Answer: @Test public void getConfigList() { CORSWithCredentialsFilter tested = getTested(); Assert.assertNull(tested.getConfigList(null, KEY)); Map<String, Object> config = new HashMap<>(); Assert.assertNull(tested.getConfigList(config, KEY)); config.put(KEY, "aaa"); Assert.assertNull(tested.getConfigList(config, KEY)); List<String> list = new ArrayList<>(); config.put(KEY, list); Assert.assertNull(tested.getConfigList(config, KEY)); list.add("aaa"); Assert.assertEquals(list, tested.getConfigList(config, KEY)); }
### Question: ESProxyFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { useStatsClient = !SearchUtils.isBlank(filterConfig.getInitParameter(CFG_USE_STATS_CLIENT)); proxyClient = HttpClients.custom().build(); } @Override void init(FilterConfig filterConfig); @Override void destroy(); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); }### Answer: @Test public void init() throws ServletException { ESProxyFilter tested = getTested(); FilterConfig filterConfig = Mockito.mock(FilterConfig.class); Mockito.when(filterConfig.getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT)).thenReturn(null); tested.init(filterConfig); Assert.assertFalse(tested.useStatsClient); Assert.assertNotNull(tested.proxyClient); Mockito.verify(filterConfig).getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT); tested.destroy(); Assert.assertNull(tested.proxyClient); Mockito.reset(filterConfig); Mockito.when(filterConfig.getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT)).thenReturn(""); tested.init(filterConfig); Assert.assertFalse(tested.useStatsClient); tested.destroy(); Mockito.reset(filterConfig); Mockito.when(filterConfig.getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT)).thenReturn(" "); tested.init(filterConfig); Assert.assertFalse(tested.useStatsClient); tested.destroy(); Mockito.reset(filterConfig); Mockito.when(filterConfig.getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT)).thenReturn("yes"); tested.init(filterConfig); Assert.assertTrue(tested.useStatsClient); tested.destroy(); Mockito.reset(filterConfig); Mockito.when(filterConfig.getInitParameter(ESProxyFilter.CFG_USE_STATS_CLIENT)).thenReturn("true"); tested.init(filterConfig); Assert.assertTrue(tested.useStatsClient); tested.destroy(); }
### Question: ESProxyFilter implements Filter { protected ElasticsearchClientService getElasticsearchClientService() { if (useStatsClient) return statsClientService; else return searchClientService; } @Override void init(FilterConfig filterConfig); @Override void destroy(); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); }### Answer: @Test public void getElasticsearchClientService() { ESProxyFilter tested = getTested(); tested.searchClientService = Mockito.mock(SearchClientService.class); tested.statsClientService = Mockito.mock(StatsClientService.class); Assert.assertEquals(tested.searchClientService, tested.getElasticsearchClientService()); tested.useStatsClient = true; Assert.assertEquals(tested.statsClientService, tested.getElasticsearchClientService()); tested.useStatsClient = false; Assert.assertEquals(tested.searchClientService, tested.getElasticsearchClientService()); }
### Question: ESProxyFilter implements Filter { protected URI getEsNodeURI() throws ServletException { Client client = getElasticsearchClientService().getClient(); if (client == null) throw new ServletException("Elasticsearch client for " + (useStatsClient ? "stats" : "search") + " cluster is not available"); NodesInfoResponse nir = client.admin().cluster().nodesInfo(new NodesInfoRequest().http(true)).actionGet(); NodeInfo[] nis = nir.getNodes(); if (nis == null \|\| nis.length == 0) { throw new ServletException("Elasticsearch node is not available"); } NodeInfo ni = nir.getAt(0); HttpInfo hi = ni.getHttp(); if (hi == null) { throw new ServletException("HTTP Connector is not available for Elasticsearch node " + ni.getNode().getName()); } TransportAddress ta = hi.getAddress().publishAddress(); if (ta == null \|\| !(ta instanceof InetSocketTransportAddress)) { throw new ServletException("HTTP Connector is not available for Elasticsearch node " + ni.getNode().getName()); } InetSocketTransportAddress a = (InetSocketTransportAddress) ta; String url = "http: try { return new URI(url); } catch (URISyntaxException e) { throw new ServletException("Generated ES URL is invalid: " + url); } } @Override void init(FilterConfig filterConfig); @Override void destroy(); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); }### Answer: @Test(expected = ServletException.class) public void getEsNodeURI() throws ServletException { ESProxyFilter tested = getTested(); tested.searchClientService = Mockito.mock(SearchClientService.class); Mockito.when(tested.searchClientService.getClient()).thenReturn(null); tested.getEsNodeURI(); }
### Question: ESProxyFilter implements Filter { protected String rewriteRequestUrl(HttpServletRequest servletRequest, URI targetUri) { StringBuilder uri = new StringBuilder(500); uri.append(targetUri); String path = servletRequest.getRequestURI(); if (!SearchUtils.isBlank(path)) { String[] pe = path.split("/"); int matchcount = 5; for (int i = 0; i < pe.length; i++) { if ("sys".equals(pe[i])) { matchcount = i + 2; } if (i > matchcount) { uri.append("/"); uri.append(pe[i]); } } } String queryString = servletRequest.getQueryString(); if (!SearchUtils.isBlank(queryString)) { uri.append('?'); uri.append(queryString); } return uri.toString(); } @Override void init(FilterConfig filterConfig); @Override void destroy(); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); }### Answer: @Test public void rewriteRequestUrl() throws URISyntaxException { ESProxyFilter tested = getTested(); URI targetUri = new URI("http: HttpServletRequest servletRequest = Mockito.mock(HttpServletRequest.class); Assert.assertEquals("http: Mockito.when(servletRequest.getRequestURI()).thenReturn("/v2/rest/sys/es/search"); Assert.assertEquals("http: Mockito.when(servletRequest.getRequestURI()).thenReturn("/v2/rest/sys/es/search/"); Assert.assertEquals("http: Mockito.when(servletRequest.getRequestURI()).thenReturn("/v2/rest/sys/es/search/_all"); Assert.assertEquals("http: Mockito.when(servletRequest.getRequestURI()).thenReturn("/v2/rest/sys/es/stats/_all/mytype"); Assert.assertEquals("http: Mockito.when(servletRequest.getRequestURI()).thenReturn("/context/v2/rest/sys/es/stats/_all/mytype"); Assert.assertEquals("http: }
### Question: ESProxyFilter implements Filter { protected boolean handleNotModifiedResponse(HttpServletResponse servletResponse, int statusCode) throws ServletException, IOException { if (statusCode == HttpServletResponse.SC_NOT_MODIFIED) { servletResponse.setIntHeader(HttpHeaders.CONTENT_LENGTH, 0); servletResponse.setStatus(HttpServletResponse.SC_NOT_MODIFIED); return true; } return false; } @Override void init(FilterConfig filterConfig); @Override void destroy(); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); }### Answer: @Test public void handleNotModifiedResponse() throws ServletException, IOException { ESProxyFilter tested = getTested(); HttpServletResponse responseMock = Mockito.mock(HttpServletResponse.class); Assert.assertTrue(tested.handleNotModifiedResponse(responseMock, HttpServletResponse.SC_NOT_MODIFIED)); Mockito.verify(responseMock).setStatus(HttpServletResponse.SC_NOT_MODIFIED); Mockito.verify(responseMock).setIntHeader(HttpHeaders.CONTENT_LENGTH, 0); Mockito.reset(responseMock); Assert.assertFalse(tested.handleNotModifiedResponse(responseMock, HttpServletResponse.SC_OK)); Mockito.verifyZeroInteractions(responseMock); }
### Question: AuthenticationUtilService { public boolean isAuthenticatedUser() { return httpRequest.getUserPrincipal() != null; } boolean isAuthenticatedUser(); Principal getAuthenticatedUserPrincipal(); boolean isUserInRole(String role); boolean isUserInAnyOfRoles(boolean acceptAdmin, String... roles); boolean isUserInAnyOfRoles(boolean acceptAdmin, Collection<String> roles); String getAuthenticatedProvider(); void checkProviderManagementPermission(String providerName); String getAuthenticatedContributor(boolean forceCreate); boolean updateAuthenticatedContributorProfile(); AuthenticatedUserType getAuthenticatedUserType(); Set<String> getUserRoles(); boolean isAuthenticatedUserOfType(AuthenticatedUserType userType); }### Answer: @Test public void isAuthenticatedUser() { AuthenticationUtilService tested = getTested(); { Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(null); Assert.assertFalse(tested.isAuthenticatedUser()); } { Mockito.reset(tested.httpRequest); Principal p = Mockito.mock(Principal.class); Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p); Assert.assertTrue(tested.isAuthenticatedUser()); } }
### Question: AuthenticationUtilService { public Principal getAuthenticatedUserPrincipal() { return httpRequest.getUserPrincipal(); } boolean isAuthenticatedUser(); Principal getAuthenticatedUserPrincipal(); boolean isUserInRole(String role); boolean isUserInAnyOfRoles(boolean acceptAdmin, String... roles); boolean isUserInAnyOfRoles(boolean acceptAdmin, Collection<String> roles); String getAuthenticatedProvider(); void checkProviderManagementPermission(String providerName); String getAuthenticatedContributor(boolean forceCreate); boolean updateAuthenticatedContributorProfile(); AuthenticatedUserType getAuthenticatedUserType(); Set<String> getUserRoles(); boolean isAuthenticatedUserOfType(AuthenticatedUserType userType); }### Answer: @Test public void getAuthenticatedUserPrincipal() { AuthenticationUtilService tested = getTested(); { Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(null); Assert.assertNull(tested.getAuthenticatedUserPrincipal()); } { Mockito.reset(tested.httpRequest); Principal p = Mockito.mock(Principal.class); Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p); Assert.assertEquals(p, tested.getAuthenticatedUserPrincipal()); } }
### Question: AuthenticationUtilService { public boolean isUserInRole(String role) { role = StringUtils.trimToNull(role); if (role == null) return false; return httpRequest.isUserInRole(role); } boolean isAuthenticatedUser(); Principal getAuthenticatedUserPrincipal(); boolean isUserInRole(String role); boolean isUserInAnyOfRoles(boolean acceptAdmin, String... roles); boolean isUserInAnyOfRoles(boolean acceptAdmin, Collection<String> roles); String getAuthenticatedProvider(); void checkProviderManagementPermission(String providerName); String getAuthenticatedContributor(boolean forceCreate); boolean updateAuthenticatedContributorProfile(); AuthenticatedUserType getAuthenticatedUserType(); Set<String> getUserRoles(); boolean isAuthenticatedUserOfType(AuthenticatedUserType userType); }### Answer: @Test public void isUserInRole() { AuthenticationUtilService tested = getTested(); Mockito.when(tested.httpRequest.isUserInRole(ROLE1)).thenReturn(false); Mockito.when(tested.httpRequest.isUserInRole(ROLE2)).thenReturn(true); { Assert.assertFalse(tested.isUserInRole(null)); Mockito.verifyZeroInteractions(tested.httpRequest); } { Assert.assertFalse(tested.isUserInRole("")); Mockito.verifyZeroInteractions(tested.httpRequest); } { Assert.assertFalse(tested.isUserInRole(" ")); Mockito.verifyZeroInteractions(tested.httpRequest); } { Assert.assertFalse(tested.isUserInRole(ROLE1)); Mockito.verify(tested.httpRequest).isUserInRole(ROLE1); } { Assert.assertTrue(tested.isUserInRole(ROLE2)); Mockito.verify(tested.httpRequest).isUserInRole(ROLE2); } }
### Question: ElasticsearchClientService { protected TransportClient createTransportClient(Properties transportAddresses, Properties settings) { final TransportClient transportClient = new TransportClient(settingsBuilder().put(settings) .put("client.transport.sniff", true).build()); log.log(Level.INFO, "New TransportClient instance created, {0}", client); for (final String host : transportAddresses.stringPropertyNames()) { int port = Integer.parseInt(transportAddresses.getProperty(host)); log.info("Adding transport address: " + host + " port: " + port); transportClient.addTransportAddress(new InetSocketTransportAddress(host, port)); } return transportClient; } Node createEmbeddedNode(String name, Properties settings); Client getClient(); @PreDestroy void destroy(); void checkHealthOfCluster(Client client); }### Answer: @Test public void createTransportClient() { }
### Question: ElasticsearchClientService { public Node createEmbeddedNode(String name, Properties settings) throws Exception { Node node = null; try { String nodePath = appConfigurationService.getAppConfiguration().getAppDataPath(); if (nodePath != null) { nodePath = nodePath + "/" + name; } else { nodePath = name; } File pathFolder = new File(nodePath); String pathFolderName = pathFolder.getCanonicalPath(); if (!pathFolder.exists()) { if (!pathFolder.mkdirs()) { throw new IOException("Could not create a folder for Elasticsearch node [" + pathFolderName + "]"); } } Settings s = org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder().put(settings) .put("path.data", pathFolderName).build(); node = NodeBuilder.nodeBuilder().settings(s).local(true).node(); log.log(Level.INFO, "New Embedded Node instance created, {0}, location: {1}", new Object[] { node, pathFolderName }); return node; } catch (Exception e) { if (node != null) { node.close(); } throw e; } } Node createEmbeddedNode(String name, Properties settings); Client getClient(); @PreDestroy void destroy(); void checkHealthOfCluster(Client client); }### Answer: @Test public void createEmbeddedNode() { }
### Question: ElasticsearchClientService { public Client getClient() { return client; } Node createEmbeddedNode(String name, Properties settings); Client getClient(); @PreDestroy void destroy(); void checkHealthOfCluster(Client client); }### Answer: @Test public void getClient() { ElasticsearchClientService tested = getTested(); Assert.assertNull(tested.getClient()); tested.client = Mockito.mock(Client.class); Assert.assertNotNull(tested.getClient()); Assert.assertEquals(tested.client, tested.getClient()); }
### Question: ElasticsearchClientService { @PreDestroy public void destroy() { try { if (client != null) { client.close(); client = null; log.info("Elasticsearch Search Client is closed"); } } finally { if (node != null) { node.close(); node = null; log.info("Elasticsearch Search Node is closed"); } } } Node createEmbeddedNode(String name, Properties settings); Client getClient(); @PreDestroy void destroy(); void checkHealthOfCluster(Client client); }### Answer: @Test public void destroy() { ElasticsearchClientService tested = getTested(); Client clientMock = Mockito.mock(Client.class); Node nodeMock = Mockito.mock(Node.class); tested.destroy(); tested.client = clientMock; tested.node = null; tested.destroy(); Mockito.verify(clientMock).close(); Mockito.reset(nodeMock, clientMock); tested.client = null; tested.node = nodeMock; tested.destroy(); Mockito.verify(nodeMock).close(); Mockito.reset(nodeMock, clientMock); tested.client = clientMock; tested.node = nodeMock; tested.destroy(); Mockito.verify(nodeMock).close(); Mockito.verify(clientMock).close(); Mockito.reset(nodeMock, clientMock); tested.client = clientMock; tested.node = nodeMock; Mockito.doThrow(new RuntimeException()).when(clientMock).close(); try { tested.destroy(); } catch (Exception e) { } Mockito.verify(nodeMock).close(); Mockito.verify(clientMock).close(); Mockito.reset(nodeMock, clientMock); tested.client = clientMock; tested.node = nodeMock; Mockito.doThrow(new RuntimeException()).when(nodeMock).close(); try { tested.destroy(); } catch (Exception e) { } Mockito.verify(nodeMock).close(); Mockito.verify(clientMock).close(); }
### Question: SecurityService { public static void main(String[] args) throws IllegalArgumentException { if (args == null \|\| args.length < 2) { throw new IllegalArgumentException("You have to pass username (provider name) as first parameter and password as second one to obtain hash"); } Logger log = Logger.getLogger(SecurityService.class.getName()); SecurityService s = new SecurityService(); log.info("Hash for username (provider name) '" + args[0] + "' is: " + s.createPwdHash(args[0], args[1])); } static void main(String[] args); String createPwdHash(String username, String pwd); boolean checkPwdHash(String username, String pwd, String hash); }### Answer: @Test(expected = IllegalArgumentException.class) public void main_noArguments() { SecurityService.main(null); } @Test(expected = IllegalArgumentException.class) public void main_badArguments() { SecurityService.main(new String[] { "aa" }); } @Test public void main() { SecurityService.main(new String[] { "provider1", "pwd" }); SecurityService.main(new String[] { "provider2", "pwd" }); }
### Question: TaskService { public TaskManager getTaskManager() { return taskManager; } @PostConstruct synchronized void init(); @PreDestroy synchronized void destroy(); TaskManager getTaskManager(); }### Answer: @Test public void getTaskManager() { TaskService tested = getTested(); tested.taskManager = Mockito.mock(TaskManager.class); Assert.assertEquals(tested.taskManager, tested.getTaskManager()); }
### Question: StatsClientService extends ElasticsearchClientService { public boolean checkStatisticsRecordExists(StatsRecordType type, Map<String, Object> conditions) { if (!statsConfiguration.enabled()) { return false; } SearchRequestBuilder srb = new SearchRequestBuilder(client); srb.setIndices(type.getSearchIndexName()); srb.setTypes(type.getSearchIndexType()); AndFilterBuilder fb = new AndFilterBuilder(); fb.add(new TermsFilterBuilder(FIELD_TYPE, type.getSearchIndexedValue())); if (conditions != null) { for (String fieldName : conditions.keySet()) { fb.add(new TermsFilterBuilder(fieldName, conditions.get(fieldName))); } } srb.setQuery(new FilteredQueryBuilder(QueryBuilders.matchAllQuery(), fb)); srb.addField("_id"); try { SearchResponse searchResponse = srb.execute().actionGet(); return searchResponse.getHits().getTotalHits() > 0; } catch (org.elasticsearch.indices.IndexMissingException e) { return false; } } @PostConstruct void init(); @PreDestroy void destroy(); SearchResponse performSearch( StatsRecordType type, FilterBuilder filterBuilder, Integer from, Integer size, String sort); void writeStatisticsRecord(StatsRecordType type, ElasticsearchException ex, long dateInMillis, QuerySettings querySettings); void writeStatisticsRecord(StatsRecordType type, String responseUuid, SearchResponse resp, long dateInMillis, QuerySettings querySettings); void writeStatisticsRecord(StatsRecordType type, long dateInMillis, Map<String, Object> source); boolean checkStatisticsRecordExists(StatsRecordType type, Map<String, Object> conditions); Properties getSettings(); Properties getTransportSettings(); static final String FIELD_STATUS; static final String FIELD_DATE; static final String FIELD_TYPE; static final String FIELD_HITS_ID; static final String FIELD_RESPONSE_UUID; static final String CONFIG_FILE_TRANSPORT; static final String CONFIG_FILE; }### Answer: @Test public void checkStatisticsRecordExists() { }
### Question: ParsedFilterConfigService { public boolean isCacheInitialized() { return (semiParsedFilters != null && searchFilters != null); } Map<String, SemiParsedFilterConfig> getFilterConfigsForRequest(); Map<String, FilterBuilder> getSearchFiltersForRequest(); Map<String, IntervalRange> getRangeFiltersIntervals(); Set<String> getFilterNamesForDocumentField(String fieldName); boolean isCacheInitialized(); }### Answer: @Test public void isCacheInitialized() { ParsedFilterConfigService tested = getTested(); Assert.assertFalse(tested.isCacheInitialized()); tested.semiParsedFilters = new HashMap<>(); Assert.assertFalse(tested.isCacheInitialized()); tested.searchFilters = new HashMap<>(); Assert.assertTrue(tested.isCacheInitialized()); }
### Question: ParsedFilterConfigService { public Map<String, SemiParsedFilterConfig> getFilterConfigsForRequest() { if (semiParsedFilters == null) { throw new RuntimeException("Parsed filters not initialized yet. New request filters need to be " + "initialized via prepareFiltersForRequest() method. This is probably an implementation error."); } return semiParsedFilters; } Map<String, SemiParsedFilterConfig> getFilterConfigsForRequest(); Map<String, FilterBuilder> getSearchFiltersForRequest(); Map<String, IntervalRange> getRangeFiltersIntervals(); Set<String> getFilterNamesForDocumentField(String fieldName); boolean isCacheInitialized(); }### Answer: @Test(expected = RuntimeException.class) public void getFilterConfigsForRequest_notInitialized() { ParsedFilterConfigService tested = getTested(); tested.getFilterConfigsForRequest(); } @Test public void getFilterConfigsForRequest_initialized() { ParsedFilterConfigService tested = getTested(); tested.semiParsedFilters = new HashMap<>(); tested.getFilterConfigsForRequest(); }
### Question: ParsedFilterConfigService { public Map<String, FilterBuilder> getSearchFiltersForRequest() { if (searchFilters == null) { throw new RuntimeException("Search filters not initialized yet. New request filters need to be " + "initialized via prepareFiltersForRequest() method. This is probably an implementation error."); } return searchFilters; } Map<String, SemiParsedFilterConfig> getFilterConfigsForRequest(); Map<String, FilterBuilder> getSearchFiltersForRequest(); Map<String, IntervalRange> getRangeFiltersIntervals(); Set<String> getFilterNamesForDocumentField(String fieldName); boolean isCacheInitialized(); }### Answer: @Test(expected = RuntimeException.class) public void getSearchFiltersForRequest_notInitialized() { ParsedFilterConfigService tested = getTested(); tested.getSearchFiltersForRequest(); } @Test public void getSearchFiltersForRequest_initialized() { ParsedFilterConfigService tested = getTested(); tested.searchFilters = new HashMap<>(); tested.getSearchFiltersForRequest(); }
### Question: ParsedFilterConfigService { public Map<String, IntervalRange> getRangeFiltersIntervals() { if (rangeFiltersIntervals == null) { throw new RuntimeException("Range filter intervals not initialized yet. New request filters need to be " + "initialized via prepareFiltersForRequest() method. This is probably an implementation error."); } return rangeFiltersIntervals; } Map<String, SemiParsedFilterConfig> getFilterConfigsForRequest(); Map<String, FilterBuilder> getSearchFiltersForRequest(); Map<String, IntervalRange> getRangeFiltersIntervals(); Set<String> getFilterNamesForDocumentField(String fieldName); boolean isCacheInitialized(); }### Answer: @Test(expected = RuntimeException.class) public void getRangeFiltersIntervals_notInitialized() { ParsedFilterConfigService tested = getTested(); tested.getRangeFiltersIntervals(); } @Test public void getRangeFiltersIntervals_initialized() { ParsedFilterConfigService tested = getTested(); tested.rangeFiltersIntervals = new HashMap<>(); tested.getRangeFiltersIntervals(); }
### Question: RatingService { public void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event) { log.log(Level.FINE, "contributorDeletedEventHandler called for event {0}", event); if (event != null && event.getContributorCode() != null) { ratingPersistenceService.deleteRatingsForContributor(event.getContributorCode()); } else { log.warning("Invalid event " + event); } } void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event); void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void handleContentRatingFields(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); }### Answer: @Test public void contributorDeletedEventHandler() { RatingService tested = getTested(); tested.contributorDeletedEventHandler(null); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorDeletedEventHandler(new ContributorDeletedEvent("id", null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorDeletedEventHandler(new ContributorDeletedEvent("id", "code")); verify(tested.ratingPersistenceService).deleteRatingsForContributor("code"); }
### Question: RatingService { public void contentDeletedEventHandler(@Observes ContentDeletedEvent event) { log.log(Level.FINE, "contentDeletedEventHandler called for event {0}", event); if (event != null && event.getContentId() != null) { ratingPersistenceService.deleteRatingsForContent(event.getContentId()); } else { log.warning("Invalid event " + event); } } void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event); void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void handleContentRatingFields(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); }### Answer: @Test public void contentDeletedEventHandler() { RatingService tested = getTested(); tested.contentDeletedEventHandler(null); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contentDeletedEventHandler(new ContentDeletedEvent(null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contentDeletedEventHandler(new ContentDeletedEvent("id")); verify(tested.ratingPersistenceService).deleteRatingsForContent("id"); }
### Question: RatingService { public void contributorMergedEventHandler(@Observes ContributorMergedEvent event) { if (event != null && event.getContributorCodeFrom() != null && event.getContributorCodeTo() != null) { ratingPersistenceService .mergeRatingsForContributors(event.getContributorCodeFrom(), event.getContributorCodeTo()); } else { log.warning("Invalid event " + event); } } void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event); void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void handleContentRatingFields(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); }### Answer: @Test public void contributorMergedEventHandler() { RatingService tested = getTested(); tested.contributorMergedEventHandler(null); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent(null, null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent("idFrom", null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent(null, "idTo")); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent("idFrom", "idTo")); verify(tested.ratingPersistenceService).mergeRatingsForContributors("idFrom", "idTo"); }
### Question: RatingService { public void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event) { if (event != null && event.getContributorCodeFrom() != null && event.getContributorCodeTo() != null) { ratingPersistenceService .mergeRatingsForContributors(event.getContributorCodeFrom(), event.getContributorCodeTo()); } else { log.warning("Invalid event " + event); } } void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event); void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void handleContentRatingFields(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); }### Answer: @Test public void contributorCodeChangedEventHandler() { RatingService tested = getTested(); tested.contributorCodeChangedEventHandler(null); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent(null, null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent("idFrom", null)); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent(null, "idTo")); verifyZeroInteractions(tested.ratingPersistenceService); reset(tested.ratingPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent("idFrom", "idTo")); verify(tested.ratingPersistenceService).mergeRatingsForContributors("idFrom", "idTo"); }
### Question: AppConfigurationService { @PostConstruct public void loadConfig() throws IOException { loadConfig(FILENAME); } @Produces AppConfiguration getAppConfiguration(); Properties getAppConfigurationProperties(); @PostConstruct void loadConfig(); static final String CONTRIBUTORPROFILE_PROVIDER_PASSWORD; static final String FILENAME; }### Answer: @Test public void loadConfig() throws IOException { AppConfigurationService tested = new AppConfigurationService(); tested.log = Logger.getLogger("testlogger"); Assert.assertNull(tested.getAppConfiguration()); tested.loadConfig(); Assert.assertNotNull(tested.getAppConfiguration()); Assert.assertEquals(ClientType.EMBEDDED, tested.getAppConfiguration().getClientType()); Assert.assertEquals("/test/path", tested.getAppConfiguration().getAppDataPath()); Assert.assertEquals(true, tested.getAppConfiguration().isProviderCreateInitData()); tested.appConfiguration = null; tested.loadConfig("/app2.properties"); Assert.assertNotNull(tested.getAppConfiguration()); Assert.assertEquals(ClientType.TRANSPORT, tested.getAppConfiguration().getClientType()); Assert.assertEquals("/test/path/2", tested.getAppConfiguration().getAppDataPath()); Assert.assertEquals(false, tested.getAppConfiguration().isProviderCreateInitData()); tested.appConfiguration = null; try { tested.loadConfig("/app-unknown.properties"); Assert.fail("IOException expected"); } catch (IOException e) { } }
### Question: ContributorProfileService { public boolean isContributorCodeTypesSupported(String contributorCodeType) { return TSC_SUPPORTED.contains(contributorCodeType); } boolean isContributorCodeTypesSupported(String contributorCodeType); String getContributorId(String contributorCodeType, String contributorCodeValue, boolean forceCreate); String createOrUpdateProfile(String contributorCodeType, String contributorCodeValue, boolean forceUpdate); SearchResponse findByContributorCode(String contributorCode); boolean deleteByContributorCode(String code); @TransactionAttribute(TransactionAttributeType.NEVER) int fullSynContributorsAndProfiles(String contributorCodeType, Integer start, Integer size); @TransactionAttribute(TransactionAttributeType.NEVER) int createOrUpdateAllProfiles(String contributorCodeType); void contributorDeletedEventHandler(@Observes ContributorDeletedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); static final String FIELD_TSC_JBOSSORG_USERNAME; static final String FIELD_TSC_GITHUB_USERNAME; static final String SEARCH_INDEX_NAME; static final String SEARCH_INDEX_TYPE; }### Answer: @Test public void isContributorCodeTypesSupported() { ContributorProfileService tested = getTested(null); Assert.assertFalse(tested.isContributorCodeTypesSupported(null)); Assert.assertFalse(tested.isContributorCodeTypesSupported("")); Assert.assertFalse(tested.isContributorCodeTypesSupported("unknown")); Assert.assertTrue(tested.isContributorCodeTypesSupported(ContributorProfileService.FIELD_TSC_JBOSSORG_USERNAME)); }
### Question: ProjectService implements SearchableEntityService { @Override public ListRequest listRequestInit() { return entityService.listRequestInit(); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); SearchResponse findByCode(String code); SearchResponse findByTypeSpecificCode(String codeName, String codeValue); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); @Override BulkRequestBuilder prepareBulkRequest(); @Override void updateSearchIndex(BulkRequestBuilder brb, String id, Map<String, Object> entity); @Override void deleteOldFromSearchIndex(Date timestamp); static final String FIELD_CODE; static final String FIELD_NAME; static final String FIELD_TYPE_SPECIFIC_CODE; static final String SEARCH_INDEX_NAME; static final String SEARCH_INDEX_TYPE; }### Answer: @Test public void listRequestInit() { ProjectService tested = getTested(null); ListRequest expected = Mockito.mock(ListRequest.class); Mockito.when(tested.entityService.listRequestInit()).thenReturn(expected); Assert.assertEquals(expected, tested.listRequestInit()); Mockito.verify(tested.entityService).listRequestInit(); Mockito.verifyNoMoreInteractions(tested.entityService); }
### Question: ProjectService implements SearchableEntityService { @Override public ListRequest listRequestNext(ListRequest previous) { return entityService.listRequestNext(previous); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); SearchResponse findByCode(String code); SearchResponse findByTypeSpecificCode(String codeName, String codeValue); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); @Override BulkRequestBuilder prepareBulkRequest(); @Override void updateSearchIndex(BulkRequestBuilder brb, String id, Map<String, Object> entity); @Override void deleteOldFromSearchIndex(Date timestamp); static final String FIELD_CODE; static final String FIELD_NAME; static final String FIELD_TYPE_SPECIFIC_CODE; static final String SEARCH_INDEX_NAME; static final String SEARCH_INDEX_TYPE; }### Answer: @Test public void listRequestNext() { ProjectService tested = getTested(null); ListRequest expected = Mockito.mock(ListRequest.class); ListRequest prev = Mockito.mock(ListRequest.class); Mockito.when(tested.entityService.listRequestNext(prev)).thenReturn(expected); Assert.assertEquals(expected, tested.listRequestNext(prev)); Mockito.verify(tested.entityService).listRequestNext(prev); Mockito.verifyNoMoreInteractions(tested.entityService); }
### Question: ContentManipulationLockService { public boolean isLockedForProvider(String providerName) { List<String> locks = getCurrentLocks(); return locks != null && (locks.contains(API_ID_ALL) \|\| locks.contains(providerName)); } boolean isLockedForProvider(String providerName); List<String> getLockInfo(); boolean createLock(String providerName); void createLockAll(); boolean removeLock(String providerName); void removeLockAll(); static final String API_ID_ALL; }### Answer: @Test public void isLockedForProvider() { ContentManipulationLockService tested = getTested(); Assert.assertFalse(tested.isLockedForProvider(PROVIDER_1)); Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)).thenReturn( new HashMap<String, Object>()); Assert.assertFalse(tested.isLockedForProvider(PROVIDER_1)); Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)).thenReturn(createCfgFileAll()); Assert.assertTrue(tested.isLockedForProvider(PROVIDER_1)); Assert.assertTrue(tested.isLockedForProvider(PROVIDER_2)); Assert.assertTrue(tested.isLockedForProvider(PROVIDER_3)); Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)).thenReturn(createCfgFileP1P2()); Assert.assertTrue(tested.isLockedForProvider(PROVIDER_1)); Assert.assertTrue(tested.isLockedForProvider(PROVIDER_2)); Assert.assertFalse(tested.isLockedForProvider(PROVIDER_3)); }
### Question: ContentManipulationLockService { public List<String> getLockInfo() { return getCurrentLocks(); } boolean isLockedForProvider(String providerName); List<String> getLockInfo(); boolean createLock(String providerName); void createLockAll(); boolean removeLock(String providerName); void removeLockAll(); static final String API_ID_ALL; }### Answer: @Test public void getLockInfo() { ContentManipulationLockService tested = getTested(); Assert.assertNull(tested.getLockInfo()); Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)).thenReturn( new HashMap<String, Object>()); Assert.assertNull(tested.getLockInfo()); { Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)) .thenReturn(createCfgFileAll()); List<String> li = tested.getLockInfo(); Assert.assertNotNull(li); Assert.assertEquals(1, li.size()); Assert.assertTrue(li.contains(ContentManipulationLockService.API_ID_ALL)); } { Mockito.when(tested.configService.get(ContentManipulationLockService.CFGFILE_NAME)).thenReturn( createCfgFileP1P2()); List<String> li = tested.getLockInfo(); Assert.assertNotNull(li); Assert.assertEquals(2, li.size()); Assert.assertTrue(li.contains(PROVIDER_1)); Assert.assertTrue(li.contains(PROVIDER_2)); } }
### Question: ContentManipulationLockService { public void createLockAll() { synchronized (CFGFILE_NAME) { List<String> locks = new ArrayList<>(); locks.add(API_ID_ALL); storeCurrentLocks(locks); } } boolean isLockedForProvider(String providerName); List<String> getLockInfo(); boolean createLock(String providerName); void createLockAll(); boolean removeLock(String providerName); void removeLockAll(); static final String API_ID_ALL; }### Answer: @SuppressWarnings("unchecked") @Test public void createLockAll() { ContentManipulationLockService tested = getTested(); Mockito.reset(tested.configService); Mockito.doAnswer(new StoreValidationgAnswer(ContentManipulationLockService.API_ID_ALL)).when(tested.configService) .create(Mockito.eq(ContentManipulationLockService.CFGFILE_NAME), Mockito.anyMap()); tested.createLockAll(); Mockito.verify(tested.configService).create(Mockito.eq(ContentManipulationLockService.CFGFILE_NAME), Mockito.anyMap()); Mockito.verifyNoMoreInteractions(tested.configService); }
### Question: ContentManipulationLockService { public void removeLockAll() { synchronized (CFGFILE_NAME) { storeCurrentLocks(null); } } boolean isLockedForProvider(String providerName); List<String> getLockInfo(); boolean createLock(String providerName); void createLockAll(); boolean removeLock(String providerName); void removeLockAll(); static final String API_ID_ALL; }### Answer: @Test public void removeLockAll() { ContentManipulationLockService tested = getTested(); tested.removeLockAll(); Mockito.verify(tested.configService).delete(Mockito.eq(ContentManipulationLockService.CFGFILE_NAME)); Mockito.verifyNoMoreInteractions(tested.configService); }
### Question: CustomTagService { public void contentDeletedEventHandler(@Observes ContentDeletedEvent event) { log.log(Level.FINE, "contentDeletedEventHandler called for event {0}", event); if (event != null && event.getContentId() != null) { customTagPersistenceService.deleteTagsForContent(event.getContentId()); } else { log.warning("Invalid event " + event); } } void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void contentBeforeIndexedHandler(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); @SuppressWarnings("unchecked") void updateSysTagsField(Map<String, Object> source); }### Answer: @Test public void contentDeletedEventHandler() { CustomTagService tested = getTested(); tested.contentDeletedEventHandler(null); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contentDeletedEventHandler(new ContentDeletedEvent(null)); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contentDeletedEventHandler(new ContentDeletedEvent("id")); verify(tested.customTagPersistenceService).deleteTagsForContent("id"); }
### Question: CustomTagService { public void contributorMergedEventHandler(@Observes ContributorMergedEvent event) { if (event != null && event.getContributorCodeFrom() != null && event.getContributorCodeTo() != null) { customTagPersistenceService.changeOwnershipOfTags(event.getContributorCodeFrom(), event.getContributorCodeTo()); } else { log.warning("Invalid event " + event); } } void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void contentBeforeIndexedHandler(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); @SuppressWarnings("unchecked") void updateSysTagsField(Map<String, Object> source); }### Answer: @Test public void contributorMergedEventHandler() { CustomTagService tested = getTested(); tested.contributorMergedEventHandler(null); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent(null, null)); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent("idFrom", null)); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent(null, "idTo")); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorMergedEventHandler(new ContributorMergedEvent("idFrom", "idTo")); verify(tested.customTagPersistenceService).changeOwnershipOfTags("idFrom", "idTo"); }
### Question: CustomTagService { public void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event) { if (event != null && event.getContributorCodeFrom() != null && event.getContributorCodeTo() != null) { customTagPersistenceService.changeOwnershipOfTags(event.getContributorCodeFrom(), event.getContributorCodeTo()); } else { log.warning("Invalid event " + event); } } void contentDeletedEventHandler(@Observes ContentDeletedEvent event); void contentBeforeIndexedHandler(@Observes ContentBeforeIndexedEvent event); void contributorMergedEventHandler(@Observes ContributorMergedEvent event); void contributorCodeChangedEventHandler(@Observes ContributorCodeChangedEvent event); @SuppressWarnings("unchecked") void updateSysTagsField(Map<String, Object> source); }### Answer: @Test public void contributorCodeChangedEventHandler() { CustomTagService tested = getTested(); tested.contributorCodeChangedEventHandler(null); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent(null, null)); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent("idFrom", null)); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent(null, "idTo")); verifyZeroInteractions(tested.customTagPersistenceService); reset(tested.customTagPersistenceService); tested.contributorCodeChangedEventHandler(new ContributorCodeChangedEvent("idFrom", "idTo")); verify(tested.customTagPersistenceService).changeOwnershipOfTags("idFrom", "idTo"); }
### Question: ProjectRestService extends RestEntityServiceBase { @PostConstruct public void init() { setEntityService(projectService); } @PostConstruct void init(); @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) @Override @PermitAll @AuditIgnore Object getAll(@QueryParam("from") Integer from, @QueryParam("size") Integer size); @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @Override @PermitAll @AuditIgnore Object get(@PathParam("id") String id); @POST @Path("/") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@AuditContent Map<String, Object> data); @POST @Path("/{id}") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@PathParam("id") @AuditId String id, @AuditContent Map<String, Object> data); @GET @Path("/search") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object search(@Context UriInfo uriInfo); static final String PARAM_CODE; }### Answer: @Test public void init() { ProjectRestService tested = new ProjectRestService(); Assert.assertNull(tested.entityService); tested.projectService = Mockito.mock(ProjectService.class); Assert.assertNull(tested.entityService); tested.init(); Assert.assertEquals(tested.projectService, tested.entityService); }
### Question: ConfigService implements EntityService { @Override public String create(Map<String, Object> entity) { String id = entityService.create(entity); return id; } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); static final String CFGNAME_SEARCH_RESPONSE_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_QUERY_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_HIGHLIGHT_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_AGGREGATIONS_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_FILTER_FIELDS; static final String CFGNAME_NORMALIZATIONS; static final String CFGNAME_SECURITY_RESTAPI_CORS; }### Answer: @Test public void create_noid() { ConfigService tested = getTested(); { Map<String, Object> entity = new HashMap<String, Object>(); entity.put("name", "v1"); Mockito.when(tested.entityService.create(entity)).thenReturn("1"); String id = tested.create(entity); Assert.assertEquals("1", id); } } @Test public void create_id() { ConfigService tested = getTested(); { Map<String, Object> entity = new HashMap<String, Object>(); entity.put("name", "v1"); tested.create("1", entity); Mockito.verify(tested.entityService).create("1", entity); } }
### Question: ConfigService implements EntityService { @Override public void update(String id, Map<String, Object> entity) { entityService.update(id, entity); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); static final String CFGNAME_SEARCH_RESPONSE_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_QUERY_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_HIGHLIGHT_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_AGGREGATIONS_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_FILTER_FIELDS; static final String CFGNAME_NORMALIZATIONS; static final String CFGNAME_SECURITY_RESTAPI_CORS; }### Answer: @Test public void update() { ConfigService tested = getTested(); { Mockito.reset(tested.entityService); Map<String, Object> entity = new HashMap<String, Object>(); entity.put("name", "v1"); tested.update("1", entity); Mockito.verify(tested.entityService).update("1", entity); } }
### Question: ConfigService implements EntityService { @Override public void delete(String id) { entityService.delete(id); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); static final String CFGNAME_SEARCH_RESPONSE_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_QUERY_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_HIGHLIGHT_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_AGGREGATIONS_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_FILTER_FIELDS; static final String CFGNAME_NORMALIZATIONS; static final String CFGNAME_SECURITY_RESTAPI_CORS; }### Answer: @Test public void delete() throws InterruptedException { ConfigService tested = getTested(); Mockito.reset(tested.entityService); tested.delete("1"); Mockito.verify(tested.entityService).delete("1"); }
### Question: ConfigService implements EntityService { @Override public ListRequest listRequestInit() { return entityService.listRequestInit(); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); static final String CFGNAME_SEARCH_RESPONSE_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_QUERY_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_HIGHLIGHT_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_AGGREGATIONS_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_FILTER_FIELDS; static final String CFGNAME_NORMALIZATIONS; static final String CFGNAME_SECURITY_RESTAPI_CORS; }### Answer: @Test public void listRequestInit() { ConfigService tested = getTested(); ListRequest expected = Mockito.mock(ListRequest.class); Mockito.when(tested.entityService.listRequestInit()).thenReturn(expected); Assert.assertEquals(expected, tested.listRequestInit()); Mockito.verify(tested.entityService).listRequestInit(); Mockito.verifyNoMoreInteractions(tested.entityService); }
### Question: ConfigService implements EntityService { @Override public ListRequest listRequestNext(ListRequest previous) { return entityService.listRequestNext(previous); } @Override StreamingOutput getAll(Integer from, Integer size, String[] fieldsToRemove); @Override List<Map<String, Object>> getAll(); @Override Map<String, Object> get(String id); @Override String create(Map<String, Object> entity); @Override void create(String id, Map<String, Object> entity); @Override void update(String id, Map<String, Object> entity); @Override void delete(String id); @Override ListRequest listRequestInit(); @Override ListRequest listRequestNext(ListRequest previous); static final String CFGNAME_SEARCH_RESPONSE_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_QUERY_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_HIGHLIGHT_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_AGGREGATIONS_FIELDS; static final String CFGNAME_SEARCH_FULLTEXT_FILTER_FIELDS; static final String CFGNAME_NORMALIZATIONS; static final String CFGNAME_SECURITY_RESTAPI_CORS; }### Answer: @Test public void listRequestNext() { ConfigService tested = getTested(); ListRequest expected = Mockito.mock(ListRequest.class); ListRequest prev = Mockito.mock(ListRequest.class); Mockito.when(tested.entityService.listRequestNext(prev)).thenReturn(expected); Assert.assertEquals(expected, tested.listRequestNext(prev)); Mockito.verify(tested.entityService).listRequestNext(prev); Mockito.verifyNoMoreInteractions(tested.entityService); }
### Question: ProjectRestService extends RestEntityServiceBase { @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @Override @PermitAll @AuditIgnore public Object get(@PathParam("id") String id) { Principal principal = securityContext.getUserPrincipal(); if (principal == null) { return super.getFiltered(id, fieldsToRemove); } else { return super.get(id); } } @PostConstruct void init(); @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) @Override @PermitAll @AuditIgnore Object getAll(@QueryParam("from") Integer from, @QueryParam("size") Integer size); @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @Override @PermitAll @AuditIgnore Object get(@PathParam("id") String id); @POST @Path("/") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@AuditContent Map<String, Object> data); @POST @Path("/{id}") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@PathParam("id") @AuditId String id, @AuditContent Map<String, Object> data); @GET @Path("/search") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object search(@Context UriInfo uriInfo); static final String PARAM_CODE; }### Answer: @Test public void get_ok() { ProjectRestService tested = getTested(); Map<String, Object> m = new HashMap<String, Object>(); Mockito.when(tested.entityService.get("10")).thenReturn(m); Assert.assertEquals(m, tested.get("10")); } @Test(expected = RuntimeException.class) public void get_errorFromService() { ProjectRestService tested = getTested(); Mockito.reset(tested.entityService); Mockito.when(tested.entityService.get("10")).thenThrow(new RuntimeException("my exception")); tested.get("10"); }
### Question: Jive6ContributorProfileProvider implements ContributorProfileProvider { protected List<String> getEmails(List<Map<String, Object>> emailsObject) { List<String> ret = new ArrayList<>(); if (emailsObject != null) { for (Map<String, Object> emailObject : emailsObject) { String email = SearchUtils.trimToNull((String) emailObject.get("value")); if (email != null && !ret.contains(email)) { ret.add(email); } } } return ret; } @PostConstruct void init(); @Override List<ContributorProfile> getAllProfiles(Integer start, Integer size); @Override ContributorProfile getProfile(String jbossorgUsername); @PreDestroy void destroy(); static final String JIVE_PROFILE_REST_API; static final String JIVE_ALL_PROFILES_REST_API; }### Answer: @Test public void getEmails() { Jive6ContributorProfileProvider tested = getTested(); Assert.assertEquals(0, tested.getEmails(null).size()); List<Map<String, Object>> emailsObject = new ArrayList<>(); Assert.assertEquals(0, tested.getEmails(emailsObject).size()); emailsObject.add(createEmailStructure("test@test.com", false)); Assert.assertTrue(tested.getEmails(emailsObject).contains("test@test.com")); emailsObject.add(createEmailStructure("", false)); emailsObject.add(createEmailStructure("test@test.com ", false)); emailsObject.add(createEmailStructure(" test2@test.com ", false)); Assert.assertEquals(2, tested.getEmails(emailsObject).size()); Assert.assertTrue(tested.getEmails(emailsObject).contains("test@test.com")); Assert.assertTrue(tested.getEmails(emailsObject).contains("test2@test.com")); }
### Question: TaskPersisterJpa implements TaskPersister { @Override public TaskStatusInfo getTaskStatusInfo(String id) { return em.find(TaskStatusInfo.class, id); } TaskPersisterJpa(); @Override String createTask(String taskType, Map<String, Object> taskConfig); @Override List<TaskStatusInfo> listTasks(String taskTypeFilter, List<TaskStatus> taskStatusFilter, int from, int size); @Override TaskStatusInfo getTaskStatusInfo(String id); @Override boolean markTaskToBeCancelled(String id); @Override boolean changeTaskStatus(String id, TaskStatus taskStatusNew, String message); @Override void writeTaskLog(String id, String message); @Override TaskStatusInfo getTaskToRun(String nodeId); @Override void heartbeat(String nodeId, Set<String> runningTasksId, long failoverTimeout); static final long FAILOVER_DELAY_10; static final long FAILOVER_DELAY_30; static final long FAILOVER_DELAY_100; }### Answer: @Test public void getTaskStatusInfo() { TaskPersisterJpa tested = getTested(); { Mockito.when(tested.em.find(TaskStatusInfo.class, "myid")).thenReturn(null); Assert.assertNull(tested.getTaskStatusInfo("myid")); Mockito.verify(tested.em).find(TaskStatusInfo.class, "myid"); } { Mockito.reset(tested.em); final TaskStatusInfo ret = createTaskStatusInfoWithStatus(TaskStatus.FAILOVER); Mockito.when(tested.em.find(TaskStatusInfo.class, "myid")).thenReturn(ret); Assert.assertEquals(ret, tested.getTaskStatusInfo("myid")); Mockito.verify(tested.em).find(TaskStatusInfo.class, "myid"); } }
### Question: TaskRunner extends Thread { protected void interruptRunningTasks() { boolean interruptedSomething = false; synchronized (runningTasks) { for (Task task : runningTasks.values()) { if (task.isAlive()) { task.interrupt(); interruptedSomething = true; } } } if (interruptedSomething) { log.info("Giving some time for executed tasks to be finished"); try { Thread.sleep(2000); } catch (InterruptedException e) { } } } TaskRunner(String nodeId, TaskFactory taskFactory, TaskPersister taskPersister); protected TaskRunner(); @Override void run(); void cancelTask(String taskId); void notifyNewTaskAvailableForRun(); }### Answer: @Test public void interruptRunningTasks() throws InterruptedException { TaskRunner tested = getTested(); tested.runningTasks.put("t1", createTaskMock(true)); tested.runningTasks.put("t2", createTaskMock(false)); tested.runningTasks.put("t3", createTaskMock(true)); tested.runningTasks.put("t4", createTaskMock(false)); tested.runningTasks.put("t5", createTaskMock(true)); tested.runningTasks.put("t6", createTaskMock(true)); Thread.sleep(200); tested.interruptRunningTasks(); for (Task task : tested.runningTasks.values()) { Assert.assertTrue(!task.isAlive() \|\| task.isInterrupted()); } }
### Question: TaskRunner extends Thread { public void cancelTask(String taskId) { synchronized (runningTasks) { Task t = runningTasks.get(taskId); if (t != null && t.isAlive()) { t.setCanceled(true); t.interrupt(); } } } TaskRunner(String nodeId, TaskFactory taskFactory, TaskPersister taskPersister); protected TaskRunner(); @Override void run(); void cancelTask(String taskId); void notifyNewTaskAvailableForRun(); }### Answer: @Test public void cancelTask() throws InterruptedException { TaskRunner tested = getTested(); tested.cancelTask("unknown"); Task t1 = createTaskMock(true); Task t2 = createTaskMock(false); tested.runningTasks.put("t1", t1); tested.runningTasks.put("t2", t2); Thread.sleep(700); tested.cancelTask("t1"); tested.cancelTask("t2"); Assert.assertTrue(t1.isCanceledOrInterrupted()); Assert.assertFalse(t2.isCanceledOrInterrupted()); }
### Question: TaskRunner extends Thread { protected void removeFinished() { synchronized (runningTasks) { Set<String> rem = new HashSet<>(); for (String taskId : runningTasks.keySet()) { if (!runningTasks.get(taskId).isAlive()) { rem.add(taskId); } } if (!rem.isEmpty()) { for (String t : rem) runningTasks.remove(t); } } } TaskRunner(String nodeId, TaskFactory taskFactory, TaskPersister taskPersister); protected TaskRunner(); @Override void run(); void cancelTask(String taskId); void notifyNewTaskAvailableForRun(); }### Answer: @Test public void removeFinished() throws InterruptedException { TaskRunner tested = getTested(); tested.removeFinished(); Assert.assertEquals(0, tested.runningTasks.size()); Task t1 = createTaskMock(true); Task t3 = createTaskMock(true); tested.runningTasks.put("t1", t1); tested.runningTasks.put("t2", createTaskMock(false)); tested.runningTasks.put("t3", t3); tested.runningTasks.put("t4", createTaskMock(false)); Thread.sleep(1000); tested.removeFinished(); Assert.assertEquals(2, tested.runningTasks.size()); Assert.assertEquals(t1, tested.runningTasks.get("t1")); Assert.assertEquals(t3, tested.runningTasks.get("t3")); }
### Question: TaskManager { public boolean cancelTask(String id) { if (id == null) return false; boolean ret = taskPersister.markTaskToBeCancelled(id); if (ret && taskRunner != null) { taskRunner.cancelTask(id); } return ret; } TaskManager(String nodeId, TaskFactory taskFactory, TaskPersister taskPersister); synchronized void startTasksExecution(); synchronized void stopTasksExecution(); List<String> listSupportedTaskTypes(); String createTask(String taskType, Map<String, Object> taskConfig); TaskStatusInfo getTaskStatusInfo(String id); boolean cancelTask(String id); List<TaskStatusInfo> listTasks(String taskTypeFilter, List<TaskStatus> taskStatusFilter, int from, int size); String getNodeId(); TaskFactory getTaskFactory(); TaskPersister getTaskPersister(); TaskRunner getTaskRunner(); }### Answer: @Test public void cancelTask() { TaskManager tested = getTested(); Mockito.when(tested.taskPersister.markTaskToBeCancelled("1")).thenReturn(true); Mockito.when(tested.taskPersister.markTaskToBeCancelled("2")).thenReturn(false); tested.cancelTask("1"); Mockito.verify(tested.taskPersister).markTaskToBeCancelled("1"); Mockito.verify(tested.taskRunner).cancelTask("1"); tested.cancelTask("2"); Mockito.verify(tested.taskPersister).markTaskToBeCancelled("1"); Mockito.verifyNoMoreInteractions(tested.taskRunner); tested.taskRunner = null; Mockito.verify(tested.taskPersister, Mockito.times(1)).markTaskToBeCancelled("1"); }
### Question: TaskManager { public String createTask(String taskType, Map<String, Object> taskConfig) throws UnsupportedTaskException, TaskConfigurationException { taskFactory.createTask(taskType, taskConfig); String id = taskPersister.createTask(taskType, taskConfig); taskRunner.notifyNewTaskAvailableForRun(); return id; } TaskManager(String nodeId, TaskFactory taskFactory, TaskPersister taskPersister); synchronized void startTasksExecution(); synchronized void stopTasksExecution(); List<String> listSupportedTaskTypes(); String createTask(String taskType, Map<String, Object> taskConfig); TaskStatusInfo getTaskStatusInfo(String id); boolean cancelTask(String id); List<TaskStatusInfo> listTasks(String taskTypeFilter, List<TaskStatus> taskStatusFilter, int from, int size); String getNodeId(); TaskFactory getTaskFactory(); TaskPersister getTaskPersister(); TaskRunner getTaskRunner(); }### Answer: @Test public void createTask() throws UnsupportedTaskException, TaskConfigurationException { TaskManager tested = getTested(); Map<String, Object> taskConfig = new HashMap<String, Object>(); Mockito.when(tested.taskFactory.createTask("tasktype", taskConfig)).thenReturn(Mockito.mock(Task.class)); Mockito.when(tested.taskPersister.createTask("tasktype", taskConfig)).thenReturn("myid"); Assert.assertEquals("myid", tested.createTask("tasktype", taskConfig)); Mockito.verify(tested.taskRunner).notifyNewTaskAvailableForRun(); Mockito.reset(tested.taskFactory, tested.taskPersister, tested.taskRunner); Mockito.when(tested.taskFactory.createTask("tasktype", taskConfig)).thenThrow(new UnsupportedTaskException("")); try { tested.createTask("tasktype", taskConfig); Assert.fail("UnsupportedTaskException expected"); } catch (UnsupportedTaskException e) { } Mockito.verifyZeroInteractions(tested.taskPersister, tested.taskRunner); }
### Question: Task extends Thread { public boolean isCanceledOrInterrupted() { return canceled \|\| isInterrupted(); } Task(); void setExecutionContext(String taskId, TaskExecutionContext context); @Override void run(); boolean isCanceledOrInterrupted(); void setCanceled(boolean canceled); }### Answer: @Test public void isCanceledOrInterrupted() throws InterruptedException { Task tested = getTested(); Assert.assertFalse(tested.isCanceledOrInterrupted()); tested.setCanceled(true); Assert.assertTrue(tested.isCanceledOrInterrupted()); tested.setCanceled(false); Assert.assertFalse(tested.isCanceledOrInterrupted()); }
### Question: Task extends Thread { protected void writeTaskLog(String message) { context.writeTaskLog(taskId, message); } Task(); void setExecutionContext(String taskId, TaskExecutionContext context); @Override void run(); boolean isCanceledOrInterrupted(); void setCanceled(boolean canceled); }### Answer: @Test public void writeTaskLog() { Task tested = getTested(); tested.taskId = "taskid"; tested.writeTaskLog("mymessage"); Mockito.verify(tested.context).writeTaskLog(tested.taskId, "mymessage"); }
### Question: Task extends Thread { public void setExecutionContext(String taskId, TaskExecutionContext context) { this.taskId = taskId; this.context = context; setName("Task thread for task.id=" + taskId); setDaemon(false); } Task(); void setExecutionContext(String taskId, TaskExecutionContext context); @Override void run(); boolean isCanceledOrInterrupted(); void setCanceled(boolean canceled); }### Answer: @Test public void setExecutionContext() { Task tested = getTested(); TaskExecutionContext context = Mockito.mock(TaskExecutionContext.class); tested.setExecutionContext("mytaskid", context); Assert.assertEquals("mytaskid", tested.taskId); Assert.assertEquals(context, tested.context); Assert.assertFalse(tested.isDaemon()); }
### Question: TaskStatusInfo { @JsonIgnore public Map<String, Object> getTaskConfig() { try { return SearchUtils.convertToJsonMap(taskConfigSerialized); } catch (IOException e) { throw new RuntimeException(e); } } void appendProcessingLog(String message); boolean startTaskExecution(String executionNodeId); @JsonIgnore Map<String, Object> getTaskConfig(); void setTaskConfig(Map<String, Object> taskConfig); String getId(); void setId(String id); String getTaskType(); void setTaskType(String taskType); String getTaskConfigSerialized(); void setTaskConfigSerialized(String taskConfigSerialized); Date getTaskCreatedAt(); void setTaskCreatedAt(Date taskCreatedAt); Date getLastRunStartedAt(); void setLastRunStartedAt(Date lastRunStartedAt); int getRunCount(); void setRunCount(int runCount); Date getLastRunFinishedAt(); void setLastRunFinishedAt(Date lastRunFinishedAt); String getExecutionNodeId(); void setExecutionNodeId(String executionNodeId); TaskStatus getTaskStatus(); void setTaskStatus(TaskStatus taskStatus); String getProcessingLog(); void setProcessingLog(String processingLog); boolean isCancelRequested(); void setCancelRequested(boolean cancelRequested); long getHeartbeat(); void setHeartbeat(long heartbeat); @Override String toString(); static final int FAILOVER_MAX_NUM; }### Answer: @Test public void getTaskConfig() { TaskStatusInfo tested = new TaskStatusInfo(); Assert.assertNull(tested.getTaskConfig()); tested.taskConfigSerialized = "{\"testkey\":\"testvalue\"}"; Map<String, Object> t = tested.getTaskConfig(); Assert.assertNotNull(t); Assert.assertEquals("testvalue", t.get("testkey")); try { tested.taskConfigSerialized = "{\"testkey\":\"testvalue}"; tested.getTaskConfig(); Assert.fail("RuntimeException expected"); } catch (RuntimeException e) { } }
### Question: TaskStatusInfo { public void setTaskConfig(Map<String, Object> taskConfig) { try { final String tmp = SearchUtils.convertJsonMapToString(taskConfig); this.taskConfigSerialized = tmp.trim().isEmpty() ? null : tmp; } catch (IOException e) { throw new RuntimeException(e); } } void appendProcessingLog(String message); boolean startTaskExecution(String executionNodeId); @JsonIgnore Map<String, Object> getTaskConfig(); void setTaskConfig(Map<String, Object> taskConfig); String getId(); void setId(String id); String getTaskType(); void setTaskType(String taskType); String getTaskConfigSerialized(); void setTaskConfigSerialized(String taskConfigSerialized); Date getTaskCreatedAt(); void setTaskCreatedAt(Date taskCreatedAt); Date getLastRunStartedAt(); void setLastRunStartedAt(Date lastRunStartedAt); int getRunCount(); void setRunCount(int runCount); Date getLastRunFinishedAt(); void setLastRunFinishedAt(Date lastRunFinishedAt); String getExecutionNodeId(); void setExecutionNodeId(String executionNodeId); TaskStatus getTaskStatus(); void setTaskStatus(TaskStatus taskStatus); String getProcessingLog(); void setProcessingLog(String processingLog); boolean isCancelRequested(); void setCancelRequested(boolean cancelRequested); long getHeartbeat(); void setHeartbeat(long heartbeat); @Override String toString(); static final int FAILOVER_MAX_NUM; }### Answer: @Test public void setTaskConfig() throws IOException { TaskStatusInfo tested = new TaskStatusInfo(); tested.taskConfigSerialized = "aaaa"; tested.setTaskConfig(null); Assert.assertNull(tested.taskConfigSerialized); tested.setTaskConfig(new HashMap<String, Object>()); Assert.assertEquals("{}", tested.taskConfigSerialized); Map<String, Object> m = new HashMap<String, Object>(); m.put("mk", "mv"); tested.setTaskConfig(m); TestUtils.assertJsonContent("{\"mk\":\"mv\"}", tested.taskConfigSerialized); }
### Question: ReindexingTaskFactory implements TaskFactory { @Override public List<String> listSupportedTaskTypes() { List<String> ret = new ArrayList<String>(); for (ReindexingTaskTypes t : ReindexingTaskTypes.values()) { ret.add(t.getTaskType()); } return ret; } @Override List<String> listSupportedTaskTypes(); @Override Task createTask(String taskType, Map<String, Object> taskConfig); static String getMandatoryConfigString(Map<String, Object> taskConfig, String propertyName); static String[] getMandatoryConfigStringArray(Map<String, Object> taskConfig, String propertyName); static String[] getConfigStringArray(Map<String, Object> taskConfig, String propertyName); static Integer getConfigInteger(Map<String, Object> taskConfig, String propertyName, boolean isMandatory); static final String CFG_PROJECT_ID_VALUE; static final String CFG_PROJECT_ID_TYPE; static final String CFG_CONTRIBUTOR_ID_VALUE; static final String CFG_CONTRIBUTOR_ID_TYPE; static final String CFG_SYS_CONTENT_TYPE; static final String CFG_PROJECT_CODE; static final String CFG_CONTRIBUTOR_CODE; }### Answer: @Test public void listSupportedTaskTypes() { ReindexingTaskFactory tested = new ReindexingTaskFactory(); List<String> t = tested.listSupportedTaskTypes(); Assert.assertEquals(ReindexingTaskTypes.values().length, t.size()); Assert.assertTrue(t.contains(ReindexingTaskTypes.REINDEX_FROM_PERSISTENCE.getTaskType())); }
### Question: UpdateContributorProfileTask extends Task { @Override public void performTask() throws Exception { int i = 0; if (contributorCodeValues == null) { i = contributorProfileService.createOrUpdateAllProfiles(contributorCodeType); } else { for (String v : contributorCodeValues) { i++; contributorProfileService.createOrUpdateProfile(contributorCodeType, v, true); } } writeTaskLog(i + " contributor profiles processed."); } UpdateContributorProfileTask(ContributorProfileService contributorProfileService, Map<String, Object> taskConfig); protected UpdateContributorProfileTask(); @Override void performTask(); static final String CFG_CONTRIBUTOR_TYPE_SPECIFIC_CODE_TYPE; static final String CFG_CONTRIBUTOR_TYPE_SPECIFIC_CODE_VALUE; }### Answer: @Test public void performTask() throws Exception { UpdateContributorProfileTask tested = getTested(); tested.contributorCodeType = "cct"; tested.contributorCodeValues = null; tested.performTask(); Mockito.verify(tested.contributorProfileService).createOrUpdateAllProfiles("cct"); Mockito.verifyNoMoreInteractions(tested.contributorProfileService); Mockito.reset(tested.contributorProfileService); tested.contributorCodeValues = new String[] { "homers", "quimby" }; tested.performTask(); Mockito.verify(tested.contributorProfileService).createOrUpdateProfile("cct", "homers", true); Mockito.verify(tested.contributorProfileService).createOrUpdateProfile("cct", "quimby", true); Mockito.verifyNoMoreInteractions(tested.contributorProfileService); }
### Question: ExpiringCacheBase implements ICache<T> { @Override public void flush() { synchronized (cache) { cache.clear(); } } @Override T get(String key); @Override void put(String key, T value); @Override void flush(); }### Answer: @Test public void flush() { ExpiringCacheBase<Set<String>> tested = new ExpiringCacheBase<Set<String>>() { }; tested.ttl = 50000; Set<String> value = new HashSet<String>(); Set<String> value2 = new HashSet<String>(); Set<String> value3 = new HashSet<String>(); String key = "a"; String key2_1 = "aaa"; String key2_2 = "aaa"; String key3_1 = "aaa\|zzzzz"; String key3_2 = "aaa\|zzzzz"; tested.put(key, value); tested.put(key2_1, value2); tested.put(key3_1, value3); Assert.assertEquals(value, tested.get(key)); Assert.assertEquals(value2, tested.get(key2_1)); Assert.assertEquals(value2, tested.get(key2_2)); Assert.assertEquals(value3, tested.get(key3_1)); Assert.assertEquals(value3, tested.get(key3_2)); tested.flush(); Assert.assertNull(tested.get(key)); Assert.assertNull(tested.get(key2_1)); Assert.assertNull(tested.get(key2_2)); Assert.assertNull(tested.get(key3_1)); Assert.assertNull(tested.get(key3_2)); }
### Question: AuditService { public static Object getAnnotatedParamValue(Method method, Object[] parameters, Class<?> expectedAnnotation) { Annotation[][] annotations = method.getParameterAnnotations(); int parameterPosition = 0; for (Annotation[] paramAnnotations : annotations) { for (Annotation ann : paramAnnotations) { if (ann.annotationType().equals(expectedAnnotation)) { return parameters[parameterPosition]; } } parameterPosition++; } return null; } void auditMethod(Method method, Object[] parameters); static Object getAnnotatedParamValue(Method method, Object[] parameters, Class<?> expectedAnnotation); }### Answer: @Test public void testGetAnnotatedParamValue() throws Exception { String id = "id"; Long data = new Long(100); methodTestOkBoth(id, data); methodTestOnlyData(id, data); methodTestOnlyData(data); methodTestOnlyId(id, data); methodTestOnlyId(id); methodTestNoAnnotations(id, data); methodTestNoAnnotations(id); methodTestNoAnnotations(); }
### Question: PersistenceService { public Map<String, Object> getTableCounts() { Map<String, Object> ret = new LinkedHashMap<>(); List<String> tableNames = jdbcContentPersistenceService.getAllTableNames(); Collections.sort(tableNames); for (String tableName: tableNames) { try { ret.put(tableName, jdbcContentPersistenceService.rowCount(tableName)); } catch (Throwable e) { ret.put(tableName, "ERROR: " + e.getMessage()); } } return ret; } Map<String, Object> getTableCounts(); }### Answer: @Test public void getCountsFromTables() { Map<String, Object> data1 = new HashMap<>(); data1.put("key1", "value1"); PersistenceService tested = getTested(); tested.jdbcContentPersistenceService.store("id1", "type1", data1); Map<String, Object> result = tested.getTableCounts(); Assert.assertEquals(1 + 6, result.keySet().size()); String tableName = "data_type1"; Assert.assertEquals(1, result.get(tableName)); clearDatabase(); }
### Question: JpaRatingPersistenceService implements RatingPersistenceService { @Override public RatingStats countRatingStats(String contentId) { Object[] ret = (Object[]) em.createQuery(STAT_QUERY).setParameter(1, contentId).getSingleResult(); if (ret != null && ret.length > 0 && ret[0] != null) { return new RatingStats(contentId, (Double) ret[0], (Long) ret[1]); } return null; } @Override List<Rating> getRatings(String contributorId, String... contentId); @Override void rate(String contributorId, String contentId, int rating); @Override RatingStats countRatingStats(String contentId); @Override void mergeRatingsForContributors(String contributorIdFrom, String contributorIdTo); @Override void deleteRatingsForContributor(String contributorId); @Override void deleteRatingsForContent(String... contentId); }### Answer: @Test public void countRatingStats() { JpaRatingPersistenceService tested = getTested(); em.getTransaction().begin(); tested.rate(CONTRIB_ID_1, CONTENT_ID_1, 1); tested.rate(CONTRIB_ID_2, CONTENT_ID_1, 5); tested.rate(CONTRIB_ID_1, CONTENT_ID_3, 4); em.getTransaction().commit(); em.getTransaction().begin(); RatingStats rs = tested.countRatingStats(CONTENT_ID_1); Assert.assertEquals(CONTENT_ID_1, rs.getContentId()); Assert.assertEquals(3, rs.getAverage(), 0.01); Assert.assertEquals(2, rs.getNumber()); Assert.assertNull(tested.countRatingStats(CONTENT_ID_2)); rs = tested.countRatingStats(CONTENT_ID_3); Assert.assertEquals(CONTENT_ID_3, rs.getContentId()); Assert.assertEquals(4, rs.getAverage(), 0.01); Assert.assertEquals(1, rs.getNumber()); em.getTransaction().commit(); }
### Question: JdbcContentPersistenceService implements ContentPersistenceService { protected boolean checkTableExists(String tableName) { if (TABLES_EXISTS.isEmpty()) { cacheAllTableNames(); } boolean exists = TABLES_EXISTS.containsKey(tableName); if (!exists) { cacheAllTableNames(); exists = TABLES_EXISTS.containsKey(tableName); } return exists; } @PostConstruct void init(); @Override Map<String, Object> get(String id, String sysContentType); @Override @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) void store(String id, String sysContentType, Map<String, Object> content); @Override @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) void delete(String id, String sysContentType); List<String> getAllTableNames(); @Override ListRequest listRequestInit(String sysContentType); @Override ListRequest listRequestNext(ListRequest previous); DataSource getDataSource(); @Override int countRecords(String sysContentType); int rowCount(String tableName); }### Answer: @Test public void simulateClusterTableCreation() { JdbcContentPersistenceService tested = getTested(); Assert.assertFalse(tested.checkTableExists("table1")); createTable("TABLE1"); Assert.assertTrue(tested.checkTableExists("table1")); clearDatabase(); }
### Question: JdbcContentPersistenceService implements ContentPersistenceService { @Override public int countRecords(String sysContentType) { return rowCount(getTableName(sysContentType)); } @PostConstruct void init(); @Override Map<String, Object> get(String id, String sysContentType); @Override @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) void store(String id, String sysContentType, Map<String, Object> content); @Override @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) void delete(String id, String sysContentType); List<String> getAllTableNames(); @Override ListRequest listRequestInit(String sysContentType); @Override ListRequest listRequestNext(ListRequest previous); DataSource getDataSource(); @Override int countRecords(String sysContentType); int rowCount(String tableName); }### Answer: @Test public void countRecords() { JdbcContentPersistenceService tested = getTested(); String CT = "count_test_type"; Assert.assertEquals(0, tested.countRecords(CT)); tested.ensureTableExists(tested.getTableName(CT)); Assert.assertEquals(0, tested.countRecords(CT)); Map<String, Object> content = new HashMap<>(); tested.store("1", CT, content); Assert.assertEquals(1, tested.countRecords(CT)); tested.store("2", CT, content); tested.store("3", CT, content); tested.store("asdas", CT, content); Assert.assertEquals(4, tested.countRecords(CT)); clearDatabase(); }
### Question: JpaCustomTagPersistenceService implements CustomTagPersistenceService { @Override public void deleteTagsForContent(String... contentId) { if (contentId != null && contentId.length > 0) em.createQuery("delete from Tag t where t.contentId in ?1").setParameter(1, Arrays.asList(contentId)) .executeUpdate(); } @Override List<Tag> getTagsByContent(String... contentId); @Override List<Tag> getTagsByContentType(String contentType); @Override boolean createTag(Tag tag); @Override void deleteTag(String contentId, String tagLabel); @Override void deleteTagsForContent(String... contentId); @Override void changeOwnershipOfTags(String contributorFrom, String contributorTo); }### Answer: @Test public void deleteTagsForContent() { JpaCustomTagPersistenceService tested = getTested(); Tag tag1 = new Tag(CONTENT_TYPE_1_ID_1, CONTRIB_ID_1, "label1"); Tag tag2 = new Tag(CONTENT_TYPE_1_ID_1, CONTRIB_ID_2, "label2"); Tag tag3 = new Tag(CONTENT_TYPE_1_ID_2, CONTRIB_ID_2, "label3"); em.getTransaction().begin(); tested.createTag(tag1); tested.createTag(tag2); tested.createTag(tag3); em.getTransaction().commit(); em.getTransaction().begin(); tested.deleteTagsForContent((String[]) null); List<Tag> ret = tested.getTagsByContentType(CONTENT_TYPE_1); Assert.assertEquals(3, ret.size()); em.getTransaction().commit(); em.getTransaction().begin(); tested.deleteTagsForContent(CONTENT_TYPE_1_ID_1); ret = tested.getTagsByContentType(CONTENT_TYPE_1); Assert.assertEquals(1, ret.size()); Tag testedTag = ret.get(0); Assert.assertEquals(CONTENT_TYPE_1_ID_2, testedTag.getContentId()); Assert.assertEquals(CONTRIB_ID_2, testedTag.getContributorId()); Assert.assertEquals("label3", testedTag.getTagLabel()); em.getTransaction().commit(); }
### Question: ConfigConverter extends StringValueConverter<Config> { @Override public Config convertToModel(String id, Map<String, Object> jsonMap) throws IOException { Config c = new Config(); c.setName(id); updateValue(c, jsonMap); return c; } @Override String getId(Config jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Config jpaEntity); @Override void setValue(Config jpaEntity, String value); @Override Config convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test public void convertToModel() throws IOException { ConfigConverter converter = new ConfigConverter(); Map<String, Object> data = new HashMap<>(); Map<String, Object> sysTitleConfig = new HashMap<>(); sysTitleConfig.put("fragment_size", "-1"); sysTitleConfig.put("number_of_fragments", "0"); sysTitleConfig.put("fragment_offset", "0"); data.put("sys_title", sysTitleConfig); Config c = converter.convertToModel("search_fulltext_highlight_fields", data); assertEquals("search_fulltext_highlight_fields", c.getName()); TestUtils.assertJsonContent("{\"sys_title\":{" + "\"fragment_size\":\"-1\"," + "\"number_of_fragments\":\"0\"," + "\"fragment_offset\":\"0\"" + "}}", c.getValue()); }
### Question: QueryConverter extends StringValueConverter<Query> { @Override public Query convertToModel(String id, Map<String, Object> jsonMap) throws IOException { Query q = new Query(); q.setName(id); updateValue(q, jsonMap); return q; } @Override String getId(Query jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Query jpaEntity); @Override void setValue(Query jpaEntity, String value); @Override Query convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test public void convertToModel() throws IOException { QueryConverter converter = new QueryConverter(); Map<String, Object> data = new HashMap<String, Object>(); data.put("template", "{\"query\":{\"match_all\":{}}}"); Query p = converter.convertToModel("matchAllQuery", data); assertEquals("matchAllQuery", p.getName()); TestUtils.assertJsonContent("{\"template\":\"{\\\"query\\\":{\\\"match_all\\\":{}}}\"}", p.getValue()); }
### Question: ProviderConverter extends StringValueConverter<Provider> { @Override public Provider convertToModel(String id, Map<String, Object> jsonMap) throws IOException { Provider p = new Provider(); p.setName(id); updateValue(p, jsonMap); return p; } @Override String getId(Provider jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Provider jpaEntity); @Override void setValue(Provider jpaEntity, String value); @Override Provider convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test public void convertToModel() throws IOException { ProviderConverter converter = new ProviderConverter(); Map<String, Object> data = new HashMap<>(); data.put(ProviderService.NAME, "jbossorg"); data.put(ProviderService.SUPER_PROVIDER, true); Provider p = converter.convertToModel("jbossorg", data); assertEquals("jbossorg", p.getName()); TestUtils.assertJsonContent("{\"" + ProviderService.NAME + "\":\"jbossorg\",\"" + ProviderService.SUPER_PROVIDER + "\":true}", p.getValue()); }
### Question: ProjectConverter extends StringValueConverter<Project> { @Override public Project convertToModel(String id, Map<String, Object> jsonMap) throws IOException { Project p = new Project(); p.setCode(id); updateValue(p, jsonMap); return p; } @Override String getId(Project jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Project jpaEntity); @Override void setValue(Project jpaEntity, String value); @Override Project convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test public void convertToModel() throws IOException { ProjectConverter converter = new ProjectConverter(); { Map<String, Object> data = new HashMap<String, Object>(); data.put(ProjectService.FIELD_CODE, "as7"); data.put("name", "AS 7"); Project p = converter.convertToModel("as7", data); assertEquals("as7", p.getCode()); TestUtils.assertJsonContent("{\"name\":\"AS 7\",\"" + ProjectService.FIELD_CODE + "\":\"as7\"}", p.getValue()); } { Map<String, Object> data = new HashMap<String, Object>(); Project p = converter.convertToModel("as7", data); assertEquals("as7", p.getCode()); assertEquals("{}", p.getValue()); } { Project p = converter.convertToModel("as7", null); assertEquals("as7", p.getCode()); assertEquals("", p.getValue()); } }
### Question: ProjectConverter extends StringValueConverter<Project> { @Override public void setValue(Project jpaEntity, String value) { jpaEntity.setValue(value); } @Override String getId(Project jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Project jpaEntity); @Override void setValue(Project jpaEntity, String value); @Override Project convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test(expected = JsonParseException.class) public void convertToContentTuple_invalidContent() throws IOException { ProjectConverter tested = new ProjectConverter(); Project jpaEntity = new Project(); jpaEntity.setCode("myid"); jpaEntity.setValue("{\"code}"); tested.convertToContentTuple(jpaEntity); }
### Question: ContributorConverter extends StringValueConverter<Contributor> { @Override public Contributor convertToModel(String id, Map<String, Object> jsonMap) throws IOException { Contributor c = new Contributor(); c.setId(id); updateValue(c, jsonMap); return c; } @Override String getId(Contributor jpaEntity); @Override String getEntityIdFieldName(); @Override String getValue(Contributor jpaEntity); @Override void setValue(Contributor jpaEntity, String value); @Override Contributor convertToModel(String id, Map<String, Object> jsonMap); }### Answer: @Test public void convertToModel() throws IOException { ContributorConverter converter = new ContributorConverter(); Map<String, Object> data = new LinkedHashMap<String, Object>(); data.put("code", "John Doe<john@doe.com>"); List<String> emails = new ArrayList<String>(); emails.add("john@doe.com"); data.put("email", emails); data.put("name", "John Doé"); Contributor c = converter.convertToModel("10", data); TestUtils.assertJsonContent( "{\"code\": \"John Doe<john@doe.com>\", \"email\":[\"john@doe.com\"], \"name\": \"John Doé\"}", c.getValue()); }
### Question: Jive6ContributorProfileProvider implements ContributorProfileProvider { protected String getPrimaryEmail(List<Map<String, Object>> emailsObject) { if (emailsObject == null) { log.log(Level.FINE, "Emails not returned in response from Jive. Probably bad authentication."); return null; } for (Map<String, Object> emailObject : emailsObject) { String email = (String) emailObject.get("value"); if ((boolean) emailObject.get("primary")) { return email; } } return null; } @PostConstruct void init(); @Override List<ContributorProfile> getAllProfiles(Integer start, Integer size); @Override ContributorProfile getProfile(String jbossorgUsername); @PreDestroy void destroy(); static final String JIVE_PROFILE_REST_API; static final String JIVE_ALL_PROFILES_REST_API; }### Answer: @Test public void getPrimaryEmail() { Jive6ContributorProfileProvider tested = getTested(); Assert.assertNull(tested.getPrimaryEmail(null)); List<Map<String, Object>> emailsObject = new ArrayList<>(); Assert.assertNull(tested.getPrimaryEmail(emailsObject)); emailsObject.add(createEmailStructure("test@test.com", false)); Assert.assertNull(tested.getPrimaryEmail(emailsObject)); emailsObject.add(createEmailStructure("test2@test.com", true)); Assert.assertEquals("test2@test.com", tested.getPrimaryEmail(emailsObject)); }
### Question: RestEntityServiceBase extends RestServiceBase { @POST @Path("/") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Object create(@AuditContent Map<String, Object> data) { String id = entityService.create(data); return createResponseWithId(id); } @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object getAll(@QueryParam("from") Integer from, @QueryParam("size") Integer size); @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object get(@PathParam("id") @AuditId String id); @POST @Path("/") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@AuditContent Map<String, Object> data); @POST @Path("/{id}") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Object create(@PathParam("id") @AuditId String id, @AuditContent Map<String, Object> data); @DELETE @Path("/{id}") Object delete(@PathParam("id") @AuditId String id); }### Answer: @Test(expected = RequiredFieldException.class) public void create_id_inputParamValidation_1() { RestEntityServiceBase tested = getTested(); Map<String, Object> m = new HashMap<String, Object>(); TestUtils.assertResponseStatus(tested.create(null, m), Status.BAD_REQUEST); } @Test(expected = RequiredFieldException.class) public void create_id_inputParamValidation_2() { RestEntityServiceBase tested = getTested(); Map<String, Object> m = new HashMap<String, Object>(); TestUtils.assertResponseStatus(tested.create("", m), Status.BAD_REQUEST); }
### Question: TaskRestService extends RestServiceBase { @GET @Path("/type") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore public Object getTypes() { return taskService.getTaskManager().listSupportedTaskTypes(); } @GET @Path("/type") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object getTypes(); @GET @Path("/task") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object getTasks(@QueryParam("taskType") String taskType, @QueryParam("taskStatus") String[] taskStatus, @QueryParam("from") Integer from, @QueryParam("size") Integer size); @GET @Path("/task/{taskId}") @Produces(MediaType.APPLICATION_JSON) @AuditIgnore Object getTask(@PathParam("taskId") String taskId); @POST @Path("/task/{taskType}") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) Object createTask(@PathParam("taskType") @AuditId String taskType, @AuditContent Map<String, Object> content); @DELETE @Path("/task/{taskId}") @Produces(MediaType.APPLICATION_JSON) Object cancelTask(@PathParam("taskId") @AuditId String id); }### Answer: @Test public void getTypes() { TaskRestService tested = getTested(); TaskManager managerMock = mockTaskManager(tested); List<String> value = new ArrayList<String>(); Mockito.when(managerMock.listSupportedTaskTypes()).thenReturn(value); Assert.assertEquals(value, tested.getTypes()); Mockito.verify(managerMock).listSupportedTaskTypes(); } @Test(expected = RuntimeException.class) public void getTypes_errorFromSerice() { TaskRestService tested = getTested(); TaskManager managerMock = mockTaskManager(tested); Mockito.reset(managerMock); Mockito.when(managerMock.listSupportedTaskTypes()).thenThrow(new RuntimeException("test exception")); TestUtils.assertResponseStatus(tested.getTypes(), Status.INTERNAL_SERVER_ERROR); }
### Question: Jive6ContributorProfileProvider implements ContributorProfileProvider { @SuppressWarnings("unchecked") protected String getProfileValue(Map<String, Object> jiveObject, String jiveLabel) { if (jiveObject == null) return null; try { List<Map<String, Object>> profileObject = (List<Map<String, Object>>) jiveObject.get("profile"); if (profileObject != null) { for (Map<String, Object> profileItem : profileObject) { if (jiveLabel.equals(profileItem.get(JIVE_PROFILE_NAME_KEY))) { return (String) profileItem.get(JIVE_PROFILE_VALUE_KEY); } } } } catch (ClassCastException e) { log.warning("bad structure of jive profile data"); } return null; } @PostConstruct void init(); @Override List<ContributorProfile> getAllProfiles(Integer start, Integer size); @Override ContributorProfile getProfile(String jbossorgUsername); @PreDestroy void destroy(); static final String JIVE_PROFILE_REST_API; static final String JIVE_ALL_PROFILES_REST_API; }### Answer: @Test public void getProfileValue() { Jive6ContributorProfileProvider tested = getTested(); Assert.assertNull(tested.getProfileValue(null, "testlabel")); Map<String, Object> jiveObject = new HashMap<>(); Assert.assertNull(tested.getProfileValue(jiveObject, "testlabel")); jiveObject.put("profile", "badtype"); Assert.assertNull(tested.getProfileValue(jiveObject, "testlabel")); List<Map<String, Object>> profileObject = new ArrayList<Map<String, Object>>(); jiveObject.put("profile", profileObject); Assert.assertNull(tested.getProfileValue(jiveObject, "testlabel")); profileObject.add(createProfileValueStructure("field1", "value1")); Assert.assertNull(tested.getProfileValue(jiveObject, "testlabel")); profileObject.add(createProfileValueStructure("testlabel", "testvalue")); Assert.assertEquals("testvalue", tested.getProfileValue(jiveObject, "testlabel")); }
### Question: IndexerRestService extends RestServiceBase { protected String extractIndexerName(Map<String, Object> ic, String contentType) throws ObjectNotFoundException { String indexerName = SearchUtils.trimToNull((String) ic.get(ProviderService.NAME)); if (indexerName == null) { throw new ObjectNotFoundException("Indexer name is not configured correctly for content type " + contentType); } return indexerName; } @POST @Path("/{type}/_force_reindex") Response forceReindex(@PathParam("type") @AuditId String type); @POST @Path("/_all/_stop") Map<String, String> stopAll(); @POST @Path("/{type}/_stop") Response stop(@PathParam("type") @AuditId String type); @POST @Path("/_all/_restart") Map<String, String> restartAll(); @POST @Path("/{type}/_restart") Response restart(@PathParam("type") @AuditId String type); @GET @Path("/_all/_status") @AuditIgnore Map<String, Object> statusAll(); @GET @Path("/{type}/_status") @AuditIgnore Object getStatus(@PathParam("type") String type); static final String INDEXER_TYPE_ES_RIVER_REMOTE; static final String INDEXER_TYPE_ES_RIVER_JIRA; }### Answer: @Test public void extractIndexerName() throws ObjectNotFoundException { IndexerRestService tested = getTested(); Map<String, Object> ic = new HashMap<>(); try { tested.extractIndexerName(ic, "type"); Assert.fail("ObjectNotFoundException expected"); } catch (ObjectNotFoundException e) { } ic.put(ProviderService.NAME, "myName"); Assert.assertEquals("myName", tested.extractIndexerName(ic, "type")); }
### Question: Jive6ContributorProfileProvider implements ContributorProfileProvider { @SuppressWarnings("unchecked") protected List<ContributorProfile> convertToProfiles(byte[] data) { List<ContributorProfile> ret = new LinkedList<>(); Map<String, Object> map = convertJSONMap(data); List<Map<String, Object>> profiles = (List<Map<String, Object>>) map.get("list"); for (Map<String, Object> profile : profiles) { ContributorProfile contributorProfile = mapRawJsonData(profile); ret.add(contributorProfile); } return ret; } @PostConstruct void init(); @Override List<ContributorProfile> getAllProfiles(Integer start, Integer size); @Override ContributorProfile getProfile(String jbossorgUsername); @PreDestroy void destroy(); static final String JIVE_PROFILE_REST_API; static final String JIVE_ALL_PROFILES_REST_API; }### Answer: @Test public void testConvertToProfiles() throws Exception { Jive6ContributorProfileProvider provider = getTested(); InputStream is = Jive6ContributorProfileProviderTest.class.getResourceAsStream("Jive6AllProfilesData.json"); List<ContributorProfile> profiles = provider.convertToProfiles(IOUtils.toByteArray(is)); ContributorProfile profile1 = profiles.get(0); Assert.assertEquals("Danielsds", profile1.getTypeSpecificCodes().get(ContributorProfileService.FIELD_TSC_JBOSSORG_USERNAME).get(0)); Assert.assertEquals("Danielsds", profile1.getFullName()); Assert.assertEquals("danielsds@fake.com", profile1.getPrimaryEmail()); ContributorProfile profile2 = profiles.get(1); Assert.assertEquals("dppsp", profile2.getTypeSpecificCodes().get(ContributorProfileService.FIELD_TSC_JBOSSORG_USERNAME).get(0)); Assert.assertEquals("dppsp", profile2.getFullName()); Assert.assertEquals("patrick@fake.com", profile2.getPrimaryEmail()); }
### Question: BylineImpl implements Byline { @Override public String getName() { return name; } @Override String getName(); @Override List<String> getOccupations(); @Override boolean isEmpty(); }### Answer: @Test public void testGetName() { final String expected = "Jane Doe"; ctx.currentResource("/content/byline"); Byline byline = ctx.request().adaptTo(Byline.class); String actual = byline.getName(); assertEquals(expected, actual); }
### Question: SimpleResourceListener implements EventHandler { public void handleEvent(final Event event) { logger.debug("Resource event: {} at: {}", event.getTopic(), event.getProperty(SlingConstants.PROPERTY_PATH)); } void handleEvent(final Event event); }### Answer: @Test public void handleEvent() { Event resourceEvent = new Event("event/topic", Collections.singletonMap(SlingConstants.PROPERTY_PATH, "/content/test")); fixture.handleEvent(resourceEvent); List<LoggingEvent> events = logger.getLoggingEvents(); assertEquals(1, events.size()); LoggingEvent event = events.get(0); assertEquals(Level.DEBUG, event.getLevel()); assertEquals(2, event.getArguments().size()); assertEquals("event/topic", event.getArguments().get(0)); assertEquals("/content/test", event.getArguments().get(1)); }
### Question: SimpleScheduledTask implements Runnable { @Override public void run() { logger.debug("SimpleScheduledTask is now running, myParameter='{}'", myParameter); } @Override void run(); }### Answer: @Test public void run() { SimpleScheduledTask.Config config = mock(SimpleScheduledTask.Config.class); when(config.myParameter()).thenReturn("parameter value"); fixture.activate(config); fixture.run(); List<LoggingEvent> events = logger.getLoggingEvents(); assertEquals(1, events.size()); LoggingEvent event = events.get(0); assertEquals(Level.DEBUG, event.getLevel()); assertEquals(1, event.getArguments().size()); assertEquals("parameter value", event.getArguments().get(0)); }
### Question: SimpleServlet extends SlingSafeMethodsServlet { @Override protected void doGet(final SlingHttpServletRequest req, final SlingHttpServletResponse resp) throws ServletException, IOException { final Resource resource = req.getResource(); resp.setContentType("text/plain"); resp.getWriter().write("Title = " + resource.getValueMap().get(JcrConstants.JCR_TITLE)); } }### Answer: @Test public void doGet() throws ServletException, IOException { context.build().resource("/content/test", "jcr:title", "resource title").commit(); context.currentResource("/content/test"); MockSlingHttpServletRequest request = context.request(); MockSlingHttpServletResponse response = context.response(); fixture.doGet(request, response); assertEquals("Title = resource title", response.getOutputAsString()); }
### Question: LoggingFilter implements Filter { @Override public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain filterChain) throws IOException, ServletException { final SlingHttpServletRequest slingRequest = (SlingHttpServletRequest) request; logger.debug("request for {}, with selector {}", slingRequest .getRequestPathInfo().getResourcePath(), slingRequest .getRequestPathInfo().getSelectorString()); filterChain.doFilter(request, response); } @Override void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain filterChain); @Override void init(FilterConfig filterConfig); @Override void destroy(); }### Answer: @Test public void doFilter() throws IOException, ServletException { MockSlingHttpServletRequest request = context.request(); MockSlingHttpServletResponse response = context.response(); MockRequestPathInfo requestPathInfo = (MockRequestPathInfo) request.getRequestPathInfo(); requestPathInfo.setResourcePath("/content/test"); requestPathInfo.setSelectorString("selectors"); fixture.init(mock(FilterConfig.class)); fixture.doFilter(request, response, mock(FilterChain.class)); fixture.destroy(); List<LoggingEvent> events = logger.getLoggingEvents(); assertEquals(1, events.size()); LoggingEvent event = events.get(0); assertEquals(Level.DEBUG, event.getLevel()); assertEquals(2, event.getArguments().size()); assertEquals("/content/test", event.getArguments().get(0)); assertEquals("selectors", event.getArguments().get(1)); }
### Question: BylineImpl implements Byline { @Override public List<String> getOccupations() { if (occupations != null) { Collections.sort(occupations); return occupations; } else { return Collections.emptyList(); } } @Override String getName(); @Override List<String> getOccupations(); @Override boolean isEmpty(); }### Answer: @Test public void testGetOccupations() { List<String> expected = new ImmutableList.Builder<String>() .add("Blogger") .add("Photographer") .add("YouTuber") .build(); ctx.currentResource("/content/byline"); Byline byline = ctx.request().adaptTo(Byline.class); List<String> actual = byline.getOccupations(); assertEquals(expected, actual); } @Test public void testGetOccupations_WithoutOccupations() { List<String> expected = Collections.emptyList(); ctx.currentResource("/content/empty"); Byline byline = ctx.request().adaptTo(Byline.class); List<String> actual = byline.getOccupations(); assertEquals(expected, actual); }
### Question: TreeWidthQueryOptimizer { public List<Integer> optimizeConstraints() { List<Integer> result = new ArrayList<>(); optimizeConstraints(result); return result; } TreeWidthQueryOptimizer(List<Constraint> fixedConstraints, List<Constraint> constraintsToOptimize, int numVariables); List<Integer> optimizeConstraints(); }### Answer: @SuppressWarnings("static-method") @Test public void test1() { Constraint constraint1 = new Constraint(); constraint1.addVariable(0); constraint1.setMaximumProduct(10l); Constraint constraint2 = new Constraint(); constraint2.addVariable(0); constraint2.addVariable(1); constraint2.setMaximumProduct(15l); Constraint constraint3 = new Constraint(); constraint3.addVariable(1); constraint3.addVariable(2); constraint3.setMaximumProduct(7l); Constraint constraint4 = new Constraint(); constraint4.addVariable(2); constraint4.setMaximumProduct(2l); List<Constraint> constraints = new ArrayList<>(); constraints.add(constraint1); constraints.add(constraint2); constraints.add(constraint3); constraints.add(constraint4); TreeWidthQueryOptimizer optimizer = new TreeWidthQueryOptimizer(new ArrayList<Constraint>(), constraints, 3); checkOptimizerResult(new int[]{3,2,1,0}, optimizer.optimizeConstraints()); }
### Question: UserServiceImpl implements UserService { @Override public UserEntity login(LoginReq loginReq) { checkParam(loginReq); UserQueryReq userQueryReq = buildUserQueryReq(loginReq); List<UserEntity> userEntityList = userDAO.findUsers(userQueryReq); if (CollectionUtils.isEmpty(userEntityList)) { throw new CommonBizException(ExpCodeEnum.LOGIN_FAIL); } return userEntityList.get(0); } @Override UserEntity login(LoginReq loginReq); @Override List<UserEntity> findUsers(UserQueryReq userQueryReq); @Override UserEntity register(RegisterReq registerReq); @Override void batchUpdateUserState(BatchReq<UserStateReq> userStateReqs); @Override void createAdminUser(AdminCreateReq adminCreateReq); @Override List<RoleEntity> findRoles(); @Override void deleteRole(String roleId); @Override void updateMenuOfRole(RoleMenuReq roleMenuReq); @Override void updatePermissionOfRole(RolePermissionReq rolePermissionReq); @Override List<PermissionEntity> findPermissions(); @Override List<MenuEntity> findMenus(); @Override List<LocationEntity> findLocations(String userId); @Override String createLocation(LocationCreateReq locationCreateReq, String userId); @Override void deleteLocation(String locationId, String userId); @Override void modifyLocation(LocationUpdateReq locationUpdateReq, String userId); }### Answer: @Test public void login() throws Exception { LoginReq loginReq = new LoginReq(); loginReq.setUsername("chai"); loginReq.setPassword("123"); UserEntity userEntity = userService.login(loginReq); System.out.println(userEntity); }
### Question: UserServiceImpl implements UserService { @Override public List<PermissionEntity> findPermissions() { return userDAO.findPermissions(); } @Override UserEntity login(LoginReq loginReq); @Override List<UserEntity> findUsers(UserQueryReq userQueryReq); @Override UserEntity register(RegisterReq registerReq); @Override void batchUpdateUserState(BatchReq<UserStateReq> userStateReqs); @Override void createAdminUser(AdminCreateReq adminCreateReq); @Override List<RoleEntity> findRoles(); @Override void deleteRole(String roleId); @Override void updateMenuOfRole(RoleMenuReq roleMenuReq); @Override void updatePermissionOfRole(RolePermissionReq rolePermissionReq); @Override List<PermissionEntity> findPermissions(); @Override List<MenuEntity> findMenus(); @Override List<LocationEntity> findLocations(String userId); @Override String createLocation(LocationCreateReq locationCreateReq, String userId); @Override void deleteLocation(String locationId, String userId); @Override void modifyLocation(LocationUpdateReq locationUpdateReq, String userId); }### Answer: @Test public void findPermissions() throws Exception { List<PermissionEntity> permissionEntityList = userService.findPermissions(); System.out.println(permissionEntityList); }
### Question: UserServiceImpl implements UserService { @Override public List<MenuEntity> findMenus() { return userDAO.findMenus(); } @Override UserEntity login(LoginReq loginReq); @Override List<UserEntity> findUsers(UserQueryReq userQueryReq); @Override UserEntity register(RegisterReq registerReq); @Override void batchUpdateUserState(BatchReq<UserStateReq> userStateReqs); @Override void createAdminUser(AdminCreateReq adminCreateReq); @Override List<RoleEntity> findRoles(); @Override void deleteRole(String roleId); @Override void updateMenuOfRole(RoleMenuReq roleMenuReq); @Override void updatePermissionOfRole(RolePermissionReq rolePermissionReq); @Override List<PermissionEntity> findPermissions(); @Override List<MenuEntity> findMenus(); @Override List<LocationEntity> findLocations(String userId); @Override String createLocation(LocationCreateReq locationCreateReq, String userId); @Override void deleteLocation(String locationId, String userId); @Override void modifyLocation(LocationUpdateReq locationUpdateReq, String userId); }### Answer: @Test public void findMenus() throws Exception { List<MenuEntity> menuEntityList = userService.findMenus(); System.out.println(menuEntityList); }
### Question: OrderServiceImpl implements OrderService { @Override public List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId) { checkParam(orderQueryReq, ExpCodeEnum.ORDERQUERYREQ_NULL); orderQueryReq.setBuyerId(buyerId); return orderDAO.findOrders(orderQueryReq); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void findOrdersForBuyer() throws Exception { OrderQueryReq orderQueryReq = new OrderQueryReq(); List<OrdersEntity> ordersEntityList = orderService.findOrdersForBuyer(orderQueryReq, BUYER_ID); System.out.println(ordersEntityList); }
### Question: OrderServiceImpl implements OrderService { @Override public List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId) { checkParam(orderQueryReq, ExpCodeEnum.ORDERQUERYREQ_NULL); orderQueryReq.setSellerId(sellerId); return orderDAO.findOrders(orderQueryReq); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void findOrdersForSeller() throws Exception { OrderQueryReq orderQueryReq = new OrderQueryReq(); List<OrdersEntity> ordersEntityList = orderService.findOrdersForSeller(orderQueryReq, SELLER_ID); System.out.println(ordersEntityList); }
### Question: OrderServiceImpl implements OrderService { @Override public String placeOrder(OrderInsertReq orderInsertReq, String buyerId) { checkParam(orderInsertReq, ExpCodeEnum.ORDER_INSERT_REQ_NULL); orderInsertReq.setUserId(buyerId); OrderProcessContext<String> context = buildContext(null, buyerId, orderInsertReq, ProcessReqEnum.PlaceOrder); processEngine.process(context); return context.getOrderProcessRsp(); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void placeOrder() throws Exception { OrderInsertReq orderInsertReq = new OrderInsertReq(); orderInsertReq.setPayModeCode(PayModeEnum.ALIPAY.getCode()); orderInsertReq.setLocationId("1"); Map<String, Integer> prodIdCountMap = Maps.newHashMap(); prodIdCountMap.put("1",1); prodIdCountMap.put("2",10); prodIdCountMap.put("3",20); orderInsertReq.setProdIdCountMap(prodIdCountMap); System.out.println(orderService.placeOrder(orderInsertReq, BUYER_ID)); }
### Question: OrderServiceImpl implements OrderService { @Override public String pay(String orderId, String userId) { OrderProcessContext<String> context = buildContext(orderId, userId,null, ProcessReqEnum.Pay); processEngine.process(context); return context.getOrderProcessRsp(); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void pay() throws Exception { orderService.pay(ORDER_ID, BUYER_ID); }
### Question: OrderServiceImpl implements OrderService { @Override public void cancelOrder(String orderId, String userId) { OrderProcessContext<String> context = buildContext(orderId, userId,null, ProcessReqEnum.CancelOrder); processEngine.process(context); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void cancelOrder() throws Exception { orderService.cancelOrder(ORDER_ID, BUYER_ID); }
### Question: OrderServiceImpl implements OrderService { @Override public void confirmDelivery(String orderId, String expressNo, String userId) { OrderProcessContext<String> context = buildContext(orderId, userId, expressNo, ProcessReqEnum.ConfirmDelivery); processEngine.process(context); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void confirmDelivery() throws Exception { orderService.confirmDelivery(ORDER_ID, "11222333", SELLER_ID); }
### Question: OrderServiceImpl implements OrderService { @Override public void confirmReceive(String orderId, String userId) { OrderProcessContext<String> context = buildContext(orderId, userId,null, ProcessReqEnum.ConfirmReceive); processEngine.process(context); } @Override List<OrdersEntity> findOrdersForBuyer(OrderQueryReq orderQueryReq, String buyerId); @Override List<OrdersEntity> findOrdersForSeller(OrderQueryReq orderQueryReq, String sellerId); @Override List<OrdersEntity> findOrdersForAdmin(OrderQueryReq orderQueryReq); @Override String placeOrder(OrderInsertReq orderInsertReq, String buyerId); @Override String pay(String orderId, String userId); @Override void cancelOrder(String orderId, String userId); @Override void confirmDelivery(String orderId, String expressNo, String userId); @Override void confirmReceive(String orderId, String userId); }### Answer: @Test public void confirmReceive() throws Exception { orderService.confirmReceive(ORDER_ID, BUYER_ID); }
### Question: ProductServiceImpl implements ProductService { @Override public Result createProduct(ProdInsertReq prodInsertReq){ checkProductParam(prodInsertReq); ProdInsertReq product = makeProdInsertReq(prodInsertReq); int result = productDAO.createProduct(product); if (result == 0){ throw new CommonBizException(ExpCodeEnum.PRODUCT_CREATE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testCreateProduct() throws Exception { ProdInsertReq prodInsertReq = new ProdInsertReq(); prodInsertReq.setProdName("香辣蟹"); prodInsertReq.setMarketPrice("99.00"); prodInsertReq.setShopPrice("88.00"); prodInsertReq.setWeight("100"); prodInsertReq.setStock(100); prodInsertReq.setTopCateEntityID("12345"); prodInsertReq.setSubCategEntityID("23456"); prodInsertReq.setCompanyEntityID("xzchain"); productService.createProduct(prodInsertReq); }
### Question: UserServiceImpl implements UserService { @Override public List<UserEntity> findUsers(UserQueryReq userQueryReq) { return userDAO.findUsers(userQueryReq); } @Override UserEntity login(LoginReq loginReq); @Override List<UserEntity> findUsers(UserQueryReq userQueryReq); @Override UserEntity register(RegisterReq registerReq); @Override void batchUpdateUserState(BatchReq<UserStateReq> userStateReqs); @Override void createAdminUser(AdminCreateReq adminCreateReq); @Override List<RoleEntity> findRoles(); @Override void deleteRole(String roleId); @Override void updateMenuOfRole(RoleMenuReq roleMenuReq); @Override void updatePermissionOfRole(RolePermissionReq rolePermissionReq); @Override List<PermissionEntity> findPermissions(); @Override List<MenuEntity> findMenus(); @Override List<LocationEntity> findLocations(String userId); @Override String createLocation(LocationCreateReq locationCreateReq, String userId); @Override void deleteLocation(String locationId, String userId); @Override void modifyLocation(LocationUpdateReq locationUpdateReq, String userId); }### Answer: @Test public void findUsers() throws Exception { UserQueryReq userQueryReq = new UserQueryReq(); userQueryReq.setUsername("cha"); userQueryReq.setOrderByRegisterTime(1); List<UserEntity> userEntityList = userService.findUsers(userQueryReq); System.out.println(userEntityList); }
### Question: ProductServiceImpl implements ProductService { @Override public Result updateProduct(ProdUpdateReq prodUpdateReq) { int result = productDAO.updateProduct(prodUpdateReq); if (result == 0){ throw new CommonBizException(ExpCodeEnum.PRODUCT_UPDATE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testUpdateProduct() throws Exception { ProdUpdateReq prodUpdateReq = new ProdUpdateReq(); prodUpdateReq.setId("c142339174e74536bcbe3d277e22e031"); prodUpdateReq.setContent("不好吃不要钱"); productService.updateProduct(prodUpdateReq); }
### Question: ProductServiceImpl implements ProductService { @Override public Result createCategoty(CategoryEntity categoryEntity) { if (StringUtils.isEmpty(categoryEntity.getCategory())){ throw new CommonBizException(ExpCodeEnum.CATEGORY_NAME_NULL); } CategoryEntity category = makeCateInsert(categoryEntity); int result = categoryDAO.createCategoty(category); if (result == 0){ throw new CommonBizException(ExpCodeEnum.CATEGORY_CREATE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testCreateCate(){ CategoryEntity categoryEntity = new CategoryEntity(); categoryEntity.setCategory("学弟出品2"); categoryEntity.setParentId("d87b243d99e341d2b4af8e72bb49f6ad"); categoryEntity.setSort(11); productService.createCategoty(categoryEntity); }
### Question: ProductServiceImpl implements ProductService { @Override public Result modifyCategory(CategoryEntity categoryEntity) { int result = categoryDAO.updateCategory(categoryEntity); if (result == 0){ throw new CommonBizException(ExpCodeEnum.CATEGORY_UPDATE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testUpdateCate(){ CategoryEntity categoryEntity = new CategoryEntity(); categoryEntity.setId("d87b243d99e341d2b4af8e72bb49f6ad"); categoryEntity.setSort(35); productService.modifyCategory(categoryEntity); }
### Question: ProductServiceImpl implements ProductService { @Override public Result deleteCategory(String categoryId) { int result = productDAO.findUsedCategory(categoryId); if (result>0){ throw new CommonBizException(ExpCodeEnum.CATEGORY_HASUSED); } result = categoryDAO.deleteCategory(categoryId); if (result == 0){ throw new CommonBizException(ExpCodeEnum.CATEGORY_DELETE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testDeleteCate(){ productService.deleteCategory("3fdebb1b7f144c378b9faf9b4e89a390"); }
### Question: ProductServiceImpl implements ProductService { @Override public Result createBrand(BrandInsertReq brandInsertReq) { checkBrandParam(brandInsertReq); BrandInsertReq brand = makeBrandInsert(brandInsertReq); int result = brandDAO.createBrand(brand); if (result == 0){ throw new CommonBizException(ExpCodeEnum.BRADN_CREATE_FAIL); } return Result.newSuccessResult(); } @Override Result createProduct(ProdInsertReq prodInsertReq); @Override Result updateProduct(ProdUpdateReq prodUpdateReq); @Override Result<List<ProductEntity>> findProducts(ProdQueryReq prodQueryReq); @Override Result createCategoty(CategoryEntity categoryEntity); @Override Result modifyCategory(CategoryEntity categoryEntity); @Override Result deleteCategory(String categoryId); @Override Result createBrand(BrandInsertReq brandInsertReq); @Override Result modifyBrand(BrandInsertReq brandInsertReq); @Override Result<List<CategoryEntity>> findCategorys(CategoryQueryReq categoryQueryReq); @Override Result<List<BrandEntity>> findBrands(BrandQueryReq brandQueryReq); void checkBrandParam(BrandInsertReq brandInsertReq); }### Answer: @Test public void testCreateBrand(){ BrandInsertReq brandInsertReq = new BrandInsertReq(); brandInsertReq.setBrand("学长"); brandInsertReq.setBrandLogoUrl("XXXX.abc"); brandInsertReq.setCompanyEntityId("USER680519fdf9e04d38aef2ceeb10ebb561"); productService.createBrand(brandInsertReq); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.