method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Endpoint { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Endpoint that = (Endpoint) o; if (!httpMethod.equals(that.httpMethod)) return false; if (!uri.startsWith(that.uri)) return false; return true; } Endpoint(String uri, String httpMethod); Endpoint(String uri, String httpMethod, String queryParam, String... queryParamValues); Set<QueryParameterMatcher> getQueryParamMatchers(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void shouldEquals() { Endpoint endpointOne = new Endpoint("URI", "HTTP_METHOD"); Endpoint endpointTwo = new Endpoint("URI", "HTTP_METHOD", "QUERY_PARAM", "VALUE"); Endpoint endpointThree = new Endpoint("URI", "HTTP_METHOD", "QUERY_PARAM", "VALUE", "VALUE2"); boolean oneEqualsTwo = endpointOne.equals(endpointTwo); boolean oneEqualsThree = endpointOne.equals(endpointThree); boolean twoEqualsOne = endpointTwo.equals(endpointOne); boolean twoEqualsThree = endpointTwo.equals(endpointThree); boolean threeEqualsOne = endpointThree.equals(endpointOne); boolean threeEqualsTwo = endpointThree.equals(endpointTwo); assertTrue(oneEqualsTwo); assertTrue(oneEqualsThree); assertTrue(twoEqualsOne); assertTrue(twoEqualsThree); assertTrue(threeEqualsOne); assertTrue(threeEqualsTwo); }
|
### Question:
Endpoint { @Override public int hashCode() { int result = uri.hashCode(); result = 31 * result + httpMethod.hashCode(); return result; } Endpoint(String uri, String httpMethod); Endpoint(String uri, String httpMethod, String queryParam, String... queryParamValues); Set<QueryParameterMatcher> getQueryParamMatchers(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void shouldHashCodesEqual() { Endpoint endpointOne = new Endpoint("URI", "HTTP_METHOD"); Endpoint endpointTwo = new Endpoint("URI", "HTTP_METHOD", "QUERY_PARAM", "VALUE"); Endpoint endpointThree = new Endpoint("URI", "HTTP_METHOD", "QUERY_PARAM", "VALUE", "VALUE2"); int oneHashCode = endpointOne.hashCode(); int twoHashCode = endpointTwo.hashCode(); int threeHashCode = endpointThree.hashCode(); assertEquals(oneHashCode, twoHashCode); assertEquals(oneHashCode, threeHashCode); assertEquals(twoHashCode, threeHashCode); }
|
### Question:
Endpoint { public Set<QueryParameterMatcher> getQueryParamMatchers() { Set<QueryParameterMatcher> queryParamMatchers = new HashSet<QueryParameterMatcher>(); if (queryParam != null) { for (String queryParamValue : queryParamValues) { queryParamMatchers.add(new QueryParameterMatcher(queryParam, queryParamValue)); } } return queryParamMatchers; } Endpoint(String uri, String httpMethod); Endpoint(String uri, String httpMethod, String queryParam, String... queryParamValues); Set<QueryParameterMatcher> getQueryParamMatchers(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void shouldGetQueryParamMatchers() { Endpoint endpoint = new Endpoint("URI", "HTTP_METHOD", "QUERY_PARAM", "VALUE", "VALUE2"); Set<QueryParameterMatcher> queryParamMatchers = endpoint.getQueryParamMatchers(); assertEquals(queryParamMatchers.size(), 2); }
@Test public void shouldGetEmptyQueryParamMatchersWhenOnlyQueryParamNameSet() { Endpoint endpoint = new Endpoint("/URI_C", "POST", "QUERY_PARAM"); Set<QueryParameterMatcher> queryParamMatchers = endpoint.getQueryParamMatchers(); assertTrue(queryParamMatchers.isEmpty()); }
|
### Question:
LocalSSOTokenSessionModule implements ServerAuthModule { @Override public Class[] getSupportedMessageTypes() { return new Class[]{HttpServletRequest.class, HttpServletResponse.class}; } LocalSSOTokenSessionModule(); LocalSSOTokenSessionModule(AuthnRequestUtils requestUtils, SSOTokenFactory factory,
AuthUtilsWrapper authUtilsWrapper); @Override void initialize(MessagePolicy requestPolicy, MessagePolicy responsePolicy, CallbackHandler handler,
Map options); @Override Class[] getSupportedMessageTypes(); @Override AuthStatus validateRequest(final MessageInfo messageInfo, final Subject clientSubject,
Subject serviceSubject); @Override AuthStatus secureResponse(MessageInfo messageInfo, Subject serviceSubject); @Override void cleanSubject(MessageInfo messageInfo, Subject subject); AuthnRequestUtils getRequestUtils(); SSOTokenFactory getFactory(); }### Answer:
@Test public void shouldGetSupportedMessageTypes() { Class[] supportedMessageTypes = localSSOTokenSessionModule.getSupportedMessageTypes(); assertEquals(supportedMessageTypes.length, 2); assertEquals(supportedMessageTypes[0], HttpServletRequest.class); assertEquals(supportedMessageTypes[1], HttpServletResponse.class); }
|
### Question:
LocalSSOTokenSessionModule implements ServerAuthModule { @Override public AuthStatus secureResponse(MessageInfo messageInfo, Subject serviceSubject) { return AuthStatus.SEND_SUCCESS; } LocalSSOTokenSessionModule(); LocalSSOTokenSessionModule(AuthnRequestUtils requestUtils, SSOTokenFactory factory,
AuthUtilsWrapper authUtilsWrapper); @Override void initialize(MessagePolicy requestPolicy, MessagePolicy responsePolicy, CallbackHandler handler,
Map options); @Override Class[] getSupportedMessageTypes(); @Override AuthStatus validateRequest(final MessageInfo messageInfo, final Subject clientSubject,
Subject serviceSubject); @Override AuthStatus secureResponse(MessageInfo messageInfo, Subject serviceSubject); @Override void cleanSubject(MessageInfo messageInfo, Subject subject); AuthnRequestUtils getRequestUtils(); SSOTokenFactory getFactory(); }### Answer:
@Test public void shouldSecureResponse() { MessageInfo messageInfo = mock(MessageInfo.class); Subject serviceSubject = new Subject(); AuthStatus authStatus = localSSOTokenSessionModule.secureResponse(messageInfo, serviceSubject); assertEquals(authStatus, AuthStatus.SEND_SUCCESS); }
|
### Question:
SessionResourceAuthzFilter extends AdminAuthorizationFilter { @Override public boolean authorize(HttpServletRequest servletRequest, HttpServletResponse servletResponse) { if (servletRequest != null) { Map<String, String[]> parameterMap = servletRequest.getParameterMap(); if (parameterMap != null && parameterMap.containsKey("_action")) { String[] values = parameterMap.get("_action"); if (values != null && values.length > 0 && "logout".equalsIgnoreCase(values[0])) { return true; } } } return super.authorize(servletRequest, servletResponse); } @Inject SessionResourceAuthzFilter(SSOTokenFactory ssoTokenFactory, AuthnRequestUtils requestUtils,
SessionService sessionService, AuthUtilsWrapper authUtilsWrapper); @Override boolean authorize(HttpServletRequest servletRequest, HttpServletResponse servletResponse); }### Answer:
@Test public void shouldReturnTrueWhenRequestQueryParamsContainsActionLogout() { HttpServletRequest request = mock(HttpServletRequest.class); Map<String, String[]> parameterMap = new HashMap<String, String[]>(); given(request.getParameterMap()).willReturn(parameterMap); parameterMap.put("_action", new String[]{"logOUT"}); boolean authorized = sessionResourceAuthzFilter.authorize(request, null); assertTrue(authorized); }
@Test public void shouldFallbackToAdminOnlyAuthzAndReturnFalse() { HttpServletRequest request = mock(HttpServletRequest.class); Map<String, String> parameterMap = new HashMap<String, String>(); given(request.getParameterMap()).willReturn(parameterMap); boolean authorized = sessionResourceAuthzFilter.authorize(request, null); assertFalse(authorized); }
|
### Question:
RestAuthorizationDispatcherFilter implements Filter { public void destroy() { filterConfig = null; realmsAuthzConfiguratorClassName = null; usersAuthzConfiguratorClassName = null; groupsAuthzConfiguratorClassName = null; agentsAuthzConfiguratorClassName = null; } RestAuthorizationDispatcherFilter(); RestAuthorizationDispatcherFilter(RestDispatcher restDispatcher, AuthZFilter authZFilter); void init(FilterConfig filterConfig); void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain); void destroy(); }### Answer:
@Test public void shouldDestroyFilter() { restAuthorizationDispatcherFilter.destroy(); }
|
### Question:
RestAuthorizationDispatcherFilterConfig implements FilterConfig { public String getFilterName() { return filterConfig.getFilterName(); } RestAuthorizationDispatcherFilterConfig(final FilterConfig filterConfig,
final String authzConfiguratorClassName); String getFilterName(); ServletContext getServletContext(); String getInitParameter(String name); @SuppressWarnings("unchecked") Enumeration<String> getInitParameterNames(); }### Answer:
@Test public void shouldGetFilterName() { filterConfig.getFilterName(); verify(wrappedFilterConfig).getFilterName(); }
|
### Question:
RestAuthorizationDispatcherFilterConfig implements FilterConfig { public ServletContext getServletContext() { return filterConfig.getServletContext(); } RestAuthorizationDispatcherFilterConfig(final FilterConfig filterConfig,
final String authzConfiguratorClassName); String getFilterName(); ServletContext getServletContext(); String getInitParameter(String name); @SuppressWarnings("unchecked") Enumeration<String> getInitParameterNames(); }### Answer:
@Test public void shouldGetServletContext() { filterConfig.getServletContext(); verify(wrappedFilterConfig).getServletContext(); }
|
### Question:
RestAuthorizationDispatcherFilterConfig implements FilterConfig { public String getInitParameter(String name) { if (INIT_PARAM_AUTHZ_CONFIGURATOR.equals(name)) { return authzConfiguratorClassName; } return filterConfig.getInitParameter(name); } RestAuthorizationDispatcherFilterConfig(final FilterConfig filterConfig,
final String authzConfiguratorClassName); String getFilterName(); ServletContext getServletContext(); String getInitParameter(String name); @SuppressWarnings("unchecked") Enumeration<String> getInitParameterNames(); }### Answer:
@Test public void shouldGetConfiguratorInitParameter() { given(wrappedFilterConfig.getInitParameter("other")).willReturn("OTHER"); String initParam = filterConfig.getInitParameter("configurator"); assertEquals(initParam, authzConfiguratorClassName); }
@Test public void shouldGetOtherInitParameter() { given(wrappedFilterConfig.getInitParameter("other")).willReturn("OTHER"); String initParam = filterConfig.getInitParameter("other"); assertEquals(initParam, "OTHER"); }
|
### Question:
RestAuthorizationDispatcherFilterConfig implements FilterConfig { @SuppressWarnings("unchecked") public Enumeration<String> getInitParameterNames() { List<String> names = Collections.list(filterConfig.getInitParameterNames()); names.add(INIT_PARAM_AUTHZ_CONFIGURATOR); return Collections.enumeration(names); } RestAuthorizationDispatcherFilterConfig(final FilterConfig filterConfig,
final String authzConfiguratorClassName); String getFilterName(); ServletContext getServletContext(); String getInitParameter(String name); @SuppressWarnings("unchecked") Enumeration<String> getInitParameterNames(); }### Answer:
@Test public void shouldGetInitParameterNames() { given(wrappedFilterConfig.getInitParameterNames()).willReturn(Collections.enumeration(Collections.emptyList())); Enumeration<String> initParameterNames = filterConfig.getInitParameterNames(); verify(wrappedFilterConfig).getInitParameterNames(); assertEquals(initParameterNames.nextElement(), "configurator"); }
|
### Question:
SSOTokenFactory { public SSOToken getTokenFromId(String tokenId) { if (StringUtils.isEmpty(tokenId)) { return null; } if (debug.messageEnabled()) { debug.message("Creating SSOToken for ID: " + tokenId); } try { return manager.createSSOToken(tokenId); } catch (SSOException e) { debug.warning("Failed to create SSO Token for ID: " + tokenId, e); return null; } } @Inject SSOTokenFactory(SSOTokenManager manager); SSOTokenFactory(SSOTokenManager manager, Debug debug); SSOToken getTokenFromId(String tokenId); boolean isTokenValid(SSOToken token); SSOToken getAdminToken(); }### Answer:
@Test public void shouldRejectEmptyTokenId() { SSOTokenManager mockManager = mock(SSOTokenManager.class); SSOTokenFactory tokenFactory = new SSOTokenFactory(mockManager); assertNull(tokenFactory.getTokenFromId("")); }
@Test public void shouldRejectEmptyTokenNull() { SSOTokenManager mockManager = mock(SSOTokenManager.class); SSOTokenFactory tokenFactory = new SSOTokenFactory(mockManager); assertNull(tokenFactory.getTokenFromId(null)); }
@Test public void shouldUseManagerToCreateSSOToken() throws SSOException { String key = "badger"; SSOTokenManager mockManager = mock(SSOTokenManager.class); SSOTokenFactory tokenFactory = new SSOTokenFactory(mockManager); tokenFactory.getTokenFromId(key); verify(mockManager).createSSOToken(eq(key)); }
|
### Question:
AuthnRequestUtils { public String getTokenId(HttpServletRequest request) { return CookieUtils.getCookieValueFromReq(request, ssoTokenCookieName); } @Inject AuthnRequestUtils(@Named(SSOTOKEN_COOKIE_NAME) String ssoTokenCookieName); String getTokenId(HttpServletRequest request); static final String SSOTOKEN_COOKIE_NAME; }### Answer:
@Test public void shouldReturnNullIfNoCookies() { String key = "badger"; HttpServletRequest request = mock(HttpServletRequest.class); AuthnRequestUtils utils = new AuthnRequestUtils(key); String response = utils.getTokenId(request); assertNull(response); }
@Test public void shouldUseCookiesToFindTokenId() { String key = "badger"; HttpServletRequest request = mock(HttpServletRequest.class); given(request.getCookies()).willReturn(new Cookie[]{}); AuthnRequestUtils utils = new AuthnRequestUtils(key); utils.getTokenId(request); verify(request).getCookies(); }
@Test public void shouldUseCookieNameToSelectCookie() { String key = "badger"; HttpServletRequest request = mock(HttpServletRequest.class); Cookie one = mock(Cookie.class); given(one.getName()).willReturn(key); given(request.getCookies()).willReturn(new Cookie[]{one}); AuthnRequestUtils utils = new AuthnRequestUtils(key); utils.getTokenId(request); verify(one).getValue(); }
|
### Question:
OAuthTokenStore { public void create(JsonValue token) throws CoreTokenException { cts.create(tokenAdapter.toToken(token)); } @Inject OAuthTokenStore(CTSPersistentStore cts, TokenAdapter<JsonValue> tokenAdapter,
TokenIdFactory tokenIdFactory); void create(JsonValue token); JsonValue read(String id); void update(JsonValue token); void delete(String id); JsonValue query(Map<String, Object> queryParameters); JsonValue query(Map<String, Object> queryParameters, boolean and); }### Answer:
@Test public void shouldCreate() throws CoreTokenException { JsonValue oAuthToken = mock(JsonValue.class); Token token = mock(Token.class); given(tokenAdapter.toToken(oAuthToken)).willReturn(token); oAuthTokenStore.create(oAuthToken); verify(cts).create(token); }
|
### Question:
OAuthTokenStore { public JsonValue read(String id) throws CoreTokenException { Token token = cts.read(tokenIdFactory.getOAuthTokenId(id)); if (token == null) { return null; } return tokenAdapter.fromToken(token); } @Inject OAuthTokenStore(CTSPersistentStore cts, TokenAdapter<JsonValue> tokenAdapter,
TokenIdFactory tokenIdFactory); void create(JsonValue token); JsonValue read(String id); void update(JsonValue token); void delete(String id); JsonValue query(Map<String, Object> queryParameters); JsonValue query(Map<String, Object> queryParameters, boolean and); }### Answer:
@Test public void shouldRead() throws CoreTokenException { Token token = mock(Token.class); given(tokenIdFactory.getOAuthTokenId("ID")).willReturn("ID2"); given(cts.read("ID2")).willReturn(token); JsonValue oAuthToken = oAuthTokenStore.read("ID"); verify(tokenAdapter).fromToken(token); }
|
### Question:
OAuthTokenStore { public void update(JsonValue token) throws CoreTokenException { cts.update(tokenAdapter.toToken(token)); } @Inject OAuthTokenStore(CTSPersistentStore cts, TokenAdapter<JsonValue> tokenAdapter,
TokenIdFactory tokenIdFactory); void create(JsonValue token); JsonValue read(String id); void update(JsonValue token); void delete(String id); JsonValue query(Map<String, Object> queryParameters); JsonValue query(Map<String, Object> queryParameters, boolean and); }### Answer:
@Test public void shouldUpdate() throws CoreTokenException { JsonValue oAuthToken = mock(JsonValue.class); Token token = mock(Token.class); given(tokenAdapter.toToken(oAuthToken)).willReturn(token); oAuthTokenStore.update(oAuthToken); verify(cts).update(token); }
|
### Question:
OAuthTokenStore { public void delete(String id) throws DeleteFailedException { cts.delete(id); } @Inject OAuthTokenStore(CTSPersistentStore cts, TokenAdapter<JsonValue> tokenAdapter,
TokenIdFactory tokenIdFactory); void create(JsonValue token); JsonValue read(String id); void update(JsonValue token); void delete(String id); JsonValue query(Map<String, Object> queryParameters); JsonValue query(Map<String, Object> queryParameters, boolean and); }### Answer:
@Test public void shouldDelete() throws CoreTokenException { oAuthTokenStore.delete("ID"); verify(cts).delete("ID"); }
|
### Question:
OAuthTokenStore { public JsonValue query(Map<String, Object> queryParameters) throws CoreTokenException { return query(queryParameters, false); } @Inject OAuthTokenStore(CTSPersistentStore cts, TokenAdapter<JsonValue> tokenAdapter,
TokenIdFactory tokenIdFactory); void create(JsonValue token); JsonValue read(String id); void update(JsonValue token); void delete(String id); JsonValue query(Map<String, Object> queryParameters); JsonValue query(Map<String, Object> queryParameters, boolean and); }### Answer:
@Test public void shouldQuery() throws CoreTokenException { Map<String, Object> queryParameters = new HashMap<String, Object>(); Collection<Token> tokens = new HashSet<Token>(); given(cts.list(Matchers.<Filter>anyObject())).willReturn(tokens); oAuthTokenStore.query(queryParameters); verify(cts).list(Matchers.<Filter>anyObject()); }
|
### Question:
OpenIDPromptParameter { public boolean noPrompts() { if (isValid() && prompts.contains(PROMPT_NONE)) { return true; } return false; } OpenIDPromptParameter(String promptString); boolean noPrompts(); boolean promptLogin(); boolean promptConsent(); boolean isValid(); }### Answer:
@Test public void testNoPrompts() { String parameterString = "none"; OpenIDPromptParameter openIDPromptParameter = new OpenIDPromptParameter(parameterString); assert openIDPromptParameter.isValid(); assert openIDPromptParameter.noPrompts(); }
|
### Question:
OpenIDPromptParameter { public boolean isValid() { if (prompts.contains(PROMPT_NONE) && (prompts.contains(PROMPT_CONSENT) || prompts.contains(PROMPT_LOGIN))) { return false; } return true; } OpenIDPromptParameter(String promptString); boolean noPrompts(); boolean promptLogin(); boolean promptConsent(); boolean isValid(); }### Answer:
@Test public void testIsValidWithTwoValidValues() { String parameterString = "consent login"; OpenIDPromptParameter openIDPromptParameter = new OpenIDPromptParameter(parameterString); assert openIDPromptParameter.isValid(); }
|
### Question:
GuiceModuleCreator { public <T extends Module> T createInstance(Class<T> clazz) { try { Constructor<T> constructor = getConstructor(clazz); return constructor.newInstance(); } catch (InstantiationException e) { throw new ModuleCreationException(e); } catch (IllegalAccessException e) { throw new ModuleCreationException(e); } catch (NoSuchMethodException e) { throw new ModuleCreationException(e); } catch (InvocationTargetException e) { throw new ModuleCreationException(e); } } T createInstance(Class<T> clazz); }### Answer:
@Test public void shouldCreateInstanceWithPublicNoArgConstructor() { Class<? extends Module> moduleClass = TestModule2.class; Object module = guiceModuleCreator.createInstance(moduleClass); assertNotNull(module); }
@Test (expectedExceptions = ModuleCreationException.class) public void shouldFailToCreateInstanceWithPrivateNoArgConstructor() { Class<? extends Module> moduleClass = TestModule1.class; guiceModuleCreator.createInstance(moduleClass); fail(); }
@Test (expectedExceptions = ModuleCreationException.class) public void shouldFailToCreateInstanceWithPublicArgsConstructor() { Class<? extends Module> moduleClass = TestModule3.class; guiceModuleCreator.createInstance(moduleClass); fail(); }
|
### Question:
InjectorFactory { public synchronized Injector createInjector(Class<? extends Annotation> moduleAnnotation) { return injectorCreator.createInjector(createModules(moduleAnnotation)); } InjectorFactory(GuiceConfiguration guiceConfiguration, GuiceModuleCreator moduleCreator,
GuiceInjectorCreator injectorCreator); synchronized Injector createInjector(Class<? extends Annotation> moduleAnnotation); }### Answer:
@Test public void shouldCreateInjector() { Class<AMGuiceModule> moduleAnnotation = AMGuiceModule.class; Set<Class<?>> modules = new HashSet<Class<?>>(asList(TestModule1.class, TestModule2.class)); given(guiceConfiguration.getGuiceModuleClasses(moduleAnnotation)).willReturn(modules); TestModule1 testModule1 = mock(TestModule1.class); given(moduleCreator.createInstance(TestModule1.class)).willReturn(testModule1); TestModule2 testModule2 = mock(TestModule2.class); given(moduleCreator.createInstance(TestModule2.class)).willReturn(testModule2); Injector mockInjector = mock(Injector.class); given(injectorCreator.createInjector(Matchers.<Iterable<? extends Module>>anyObject())) .willReturn(mockInjector); Injector injector = injectorFactory.createInjector(moduleAnnotation); assertEquals(injector, mockInjector); }
@Test (expectedExceptions = IllegalArgumentException.class) public void shouldFailToCreateInjectorIfModuleDoesNotImplementInterface() { Class<AMGuiceModule> moduleAnnotation = AMGuiceModule.class; Set<Class<?>> modules = new HashSet<Class<?>>(asList(TestModule1.class, BadModule.class, TestModule2.class)); given(guiceConfiguration.getGuiceModuleClasses(moduleAnnotation)).willReturn(modules); injectorFactory.createInjector(moduleAnnotation); fail(); }
|
### Question:
JsonValueBuilder { public static JsonObject jsonValue() { return new JsonObject(); } static JsonObject jsonValue(); static JsonValue toJsonValue(String json); static ObjectMapper getObjectMapper(); }### Answer:
@Test public void shouldCreateJsonValue() { List<String> list = new ArrayList<String>(); list.add("LIST_VALUE_1"); list.add("LIST_VALUE_2"); list.add("LIST_VALUE_3"); Map<String, String> map = new LinkedHashMap<String, String>(); map.put("MAP_KEY_1", "MAP_VALUE_1"); map.put("MAP_KEY_2", "MAP_VALUE_2"); map.put("MAP_KEY_3", "MAP_VALUE_3"); Map<String, String> mapParam = new LinkedHashMap<String, String>(); mapParam.put("MAP_PARAM_KEY_1", "MAP_PARAM_VALUE_1"); mapParam.put("MAP_PARAM_KEY_2", "MAP_PARAM_VALUE_2"); JsonValue jsonValueParam1 = new JsonValue(mapParam); List<String> listParam = new ArrayList<String>(); listParam.add("LIST_PARAM_VALUE_1"); listParam.add("LIST_PARAM_VALUE_2"); JsonValue jsonValueParam2 = new JsonValue(listParam); JsonValue jsonValue = JsonValueBuilder.jsonValue() .put("KEY1", 1) .put("KEY2", 4L) .put("KEY3", 34.56) .put("KEY4", list) .put("KEY5", map) .put("KEY6", "VALUE") .put("KEY7", jsonValueParam1) .put("KEY8", jsonValueParam2) .array("KEY9") .add("KEY9_VALUE_1") .addLast("KEY9_VALUE_2") .build(); JsonValue expectedJsonValue = getExpectedJsonValue(); assertEquals(jsonValue.toString(), expectedJsonValue.toString()); }
|
### Question:
JsonValueBuilder { public static JsonValue toJsonValue(String json) throws JsonException { try { return new JsonValue(mapper.readValue(json, Map.class)); } catch (IOException e) { throw new JsonException("Failed to parse json", e); } } static JsonObject jsonValue(); static JsonValue toJsonValue(String json); static ObjectMapper getObjectMapper(); }### Answer:
@Test public void shouldConvertJsonStringToJsonValue() throws IOException { JsonValue expectedJsonValue = getExpectedJsonValue(); JsonValue jsonValue = JsonValueBuilder.toJsonValue(expectedJsonValue.toString()); assertEquals(jsonValue.toString(), expectedJsonValue.toString()); }
|
### Question:
AMKeyProvider implements KeyProvider { public java.security.PublicKey getPublicKey (String keyAlias) { if (keyAlias == null || keyAlias.length() == 0) { return null; } java.security.PublicKey pkey = null; try { X509Certificate cert = (X509Certificate) ks.getCertificate(keyAlias); pkey = cert.getPublicKey(); } catch (KeyStoreException e) { logger.error("Unable to get public key:" + keyAlias, e); } return pkey; } AMKeyProvider(); AMKeyProvider(
String keyStoreFilePropName,String keyStorePassFilePropName,
String keyStoreTypePropName, String privateKeyPassFilePropName); AMKeyProvider( boolean alreadyResolved,
String keyStoreFile,String keyStorePass,
String keyStoreType, String privateKeyPass); static String decodePassword(String password); void setLogger(Debug logger); void setKey(String storepass, String keypass); java.security.cert.X509Certificate getX509Certificate(
String certAlias); java.security.PublicKey getPublicKey(String keyAlias); java.security.PrivateKey getPrivateKey(String certAlias); PrivateKey getPrivateKey(String certAlias, String encryptedKeyPass); String getCertificateAlias(Certificate cert); char[] getKeystorePass(); String getPrivateKeyPass(); String getKeystoreType(); String getKeystoreFilePath(); KeyStore getKeyStore(); void setCertificateEntry(String certAlias, Certificate cert); Certificate getCertificate(String certAlias); void store(); Certificate getCertificate(
java.security.PublicKey publicKey); }### Answer:
@Test public void getDefaultPublicKey() { PublicKey key = amKeyProvider.getPublicKey(DEFAULT_PRIVATE_KEY_ALIAS); Assert.assertNotNull(key); }
@Test public void getPublicKey() { PublicKey key = amKeyProvider.getPublicKey(PRIVATE_KEY_ALIAS); Assert.assertNotNull(key); }
|
### Question:
AMKeyProvider implements KeyProvider { public java.security.cert.X509Certificate getX509Certificate ( String certAlias) { if (certAlias == null || certAlias.length() == 0) { return null; } java.security.cert.X509Certificate cert = null; try { cert = (X509Certificate) ks.getCertificate(certAlias); } catch (KeyStoreException e) { logger.error("Unable to get cert alias:" + certAlias, e); } return cert; } AMKeyProvider(); AMKeyProvider(
String keyStoreFilePropName,String keyStorePassFilePropName,
String keyStoreTypePropName, String privateKeyPassFilePropName); AMKeyProvider( boolean alreadyResolved,
String keyStoreFile,String keyStorePass,
String keyStoreType, String privateKeyPass); static String decodePassword(String password); void setLogger(Debug logger); void setKey(String storepass, String keypass); java.security.cert.X509Certificate getX509Certificate(
String certAlias); java.security.PublicKey getPublicKey(String keyAlias); java.security.PrivateKey getPrivateKey(String certAlias); PrivateKey getPrivateKey(String certAlias, String encryptedKeyPass); String getCertificateAlias(Certificate cert); char[] getKeystorePass(); String getPrivateKeyPass(); String getKeystoreType(); String getKeystoreFilePath(); KeyStore getKeyStore(); void setCertificateEntry(String certAlias, Certificate cert); Certificate getCertificate(String certAlias); void store(); Certificate getCertificate(
java.security.PublicKey publicKey); }### Answer:
@Test public void getDefaultX509Certificate() { X509Certificate certificate = amKeyProvider.getX509Certificate(DEFAULT_PRIVATE_KEY_ALIAS); Assert.assertNotNull(certificate); }
@Test public void getX509Certificate() { X509Certificate certificate = amKeyProvider.getX509Certificate(PRIVATE_KEY_ALIAS); Assert.assertNotNull(certificate); }
|
### Question:
Debug { public void resetDebug(String mf) { getDebugServiceInstance().resetDebug(mf); } private Debug(IDebug debugServiceInstance); static synchronized Debug getInstance(String debugName); static Collection getInstances(); String getName(); boolean messageEnabled(); boolean warningEnabled(); boolean errorEnabled(); int getState(); void message(String msg); void message(String msg, Throwable t); void warning(String msg); void warning(String msg, Throwable t); void error(String msg); void error(String msg, Throwable t); void setDebug(int debugType); void resetDebug(String mf); void setDebug(String debugType); void destroy(); static final int OFF; static final int ERROR; static final int WARNING; static final int MESSAGE; static final int ON; static final String STR_OFF; static final String STR_ERROR; static final String STR_WARNING; static final String STR_MESSAGE; static final String STR_ON; }### Answer:
@Test public void resetDebug() throws Exception { initializeProvider(DEBUG_CONFIG_FOR_TEST); IDebug debug = provider.getInstance(logName); debug.message("Should appear in log", null); checkLogFileStatus(false, DebugConstants.CONFIG_DEBUG_MERGEALL_FILE); checkLogFileStatus(true, logName); SystemPropertiesManager.initializeProperties(DebugConstants.CONFIG_DEBUG_LEVEL, DebugLevel.ERROR.getName()); debug.resetDebug(MERGE_ALL_ON); debug.error("Should appear in log", null); Assert.assertEquals(debug.getState(), DebugLevel.ERROR.getLevel(), "Debug level state"); checkLogFileStatus(true, DebugConstants.CONFIG_DEBUG_MERGEALL_FILE); }
|
### Question:
CoreTokenResource implements CollectionResourceProvider { public void deleteInstance(ServerContext serverContext, String tokenId, DeleteRequest deleteRequest, ResultHandler<Resource> handler) { try { store.delete(tokenId); Map<String, String> result = new HashMap<String, String>(); result.put(TOKEN_ID, tokenId); Resource resource = new Resource(tokenId, "0", new JsonValue(result)); handler.handleResult(resource); } catch (CoreTokenException e) { handler.handleError(generateException(e)); } } CoreTokenResource(JSONSerialisation serialisation, CTSPersistentStore store); void createInstance(ServerContext serverContext, CreateRequest createRequest, ResultHandler<Resource> handler); void deleteInstance(ServerContext serverContext, String tokenId, DeleteRequest deleteRequest, ResultHandler<Resource> handler); void readInstance(ServerContext serverContext, String tokenId, ReadRequest readRequest, ResultHandler<Resource> handler); void updateInstance(ServerContext serverContext, String tokenId, UpdateRequest updateRequest, ResultHandler<Resource> handler); void queryCollection(ServerContext serverContext, QueryRequest queryRequest, QueryResultHandler queryResultHandler); void patchInstance(ServerContext serverContext, String s, PatchRequest patchRequest, ResultHandler<Resource> handler); void actionInstance(ServerContext serverContext, String s, ActionRequest actionRequest, ResultHandler<JsonValue> jsonValueResultHandler); void actionCollection(ServerContext serverContext, ActionRequest actionRequest, ResultHandler<JsonValue> jsonValueResultHandler); }### Answer:
@Test public void shouldDeleteTokenBasedOnTokenId() throws DeleteFailedException { String one = "one"; CTSPersistentStore store = mock(CTSPersistentStore.class); CoreTokenResource resource = new CoreTokenResource(mock(JSONSerialisation.class), store); resource.deleteInstance(null, one, mock(DeleteRequest.class), mock(ResultHandler.class)); verify(store).delete(one); }
|
### Question:
LoginConfiguration { public String getSessionId() { return sessionId; } LoginConfiguration httpRequest(HttpServletRequest httpRequest); HttpServletRequest getHttpRequest(); LoginConfiguration httpResponse(HttpServletResponse httpResponse); HttpServletResponse getHttpResponse(); LoginConfiguration indexType(AuthIndexType indexType); AuthIndexType getIndexType(); LoginConfiguration indexValue(String indexValue); String getIndexValue(); LoginConfiguration sessionId(String sessionId); String getSessionId(); LoginConfiguration sessionUpgrade(String ssoTokenId); boolean isSessionUpgradeRequest(); String getSSOTokenId(); }### Answer:
@Test public void shouldGetSessionIdWhenNotSet() { LoginConfiguration loginConfiguration = new LoginConfiguration(); String sessionId = loginConfiguration.getSessionId(); assertEquals(sessionId, ""); }
|
### Question:
LoginConfiguration { public String getSSOTokenId() { return ssoTokenId; } LoginConfiguration httpRequest(HttpServletRequest httpRequest); HttpServletRequest getHttpRequest(); LoginConfiguration httpResponse(HttpServletResponse httpResponse); HttpServletResponse getHttpResponse(); LoginConfiguration indexType(AuthIndexType indexType); AuthIndexType getIndexType(); LoginConfiguration indexValue(String indexValue); String getIndexValue(); LoginConfiguration sessionId(String sessionId); String getSessionId(); LoginConfiguration sessionUpgrade(String ssoTokenId); boolean isSessionUpgradeRequest(); String getSSOTokenId(); }### Answer:
@Test public void shouldGetSessionUpgradeWhenNotSet() { LoginConfiguration loginConfiguration = new LoginConfiguration(); String ssoTokenId = loginConfiguration.getSSOTokenId(); assertEquals(ssoTokenId, ""); }
|
### Question:
LoginConfiguration { public boolean isSessionUpgradeRequest() { return !"".equals(ssoTokenId); } LoginConfiguration httpRequest(HttpServletRequest httpRequest); HttpServletRequest getHttpRequest(); LoginConfiguration httpResponse(HttpServletResponse httpResponse); HttpServletResponse getHttpResponse(); LoginConfiguration indexType(AuthIndexType indexType); AuthIndexType getIndexType(); LoginConfiguration indexValue(String indexValue); String getIndexValue(); LoginConfiguration sessionId(String sessionId); String getSessionId(); LoginConfiguration sessionUpgrade(String ssoTokenId); boolean isSessionUpgradeRequest(); String getSSOTokenId(); }### Answer:
@Test public void shouldCheckIsSessionUpgradeRequestWhenSessionUpgradeNotSet() { LoginConfiguration loginConfiguration = new LoginConfiguration(); boolean isSessionUpgradeRequest = loginConfiguration.isSessionUpgradeRequest(); assertFalse(isSessionUpgradeRequest); }
|
### Question:
LoginProcess { public Callback[] getCallbacks() { return authContext.getRequirements(); } LoginProcess(LoginAuthenticator loginAuthenticator, LoginConfiguration loginConfiguration,
AuthContextLocalWrapper authContext, CoreServicesWrapper coreServicesWrapper); LoginStage getLoginStage(); Callback[] getCallbacks(); PagePropertiesCallback getPagePropertiesCallback(); LoginProcess next(Callback[] callbacks); boolean isSuccessful(); AuthContextLocalWrapper getAuthContext(); LoginConfiguration getLoginConfiguration(); }### Answer:
@Test public void shouldGetCallbacks() { loginProcess.getCallbacks(); verify(authContext).getRequirements(); }
|
### Question:
LoginProcess { public PagePropertiesCallback getPagePropertiesCallback() { PagePropertiesCallback pagePropertiesCallback = null; for (Callback callback : authContext.getRequirements(true)) { if (callback instanceof PagePropertiesCallback) { pagePropertiesCallback = (PagePropertiesCallback) callback; break; } } return pagePropertiesCallback; } LoginProcess(LoginAuthenticator loginAuthenticator, LoginConfiguration loginConfiguration,
AuthContextLocalWrapper authContext, CoreServicesWrapper coreServicesWrapper); LoginStage getLoginStage(); Callback[] getCallbacks(); PagePropertiesCallback getPagePropertiesCallback(); LoginProcess next(Callback[] callbacks); boolean isSuccessful(); AuthContextLocalWrapper getAuthContext(); LoginConfiguration getLoginConfiguration(); }### Answer:
@Test public void shouldGetPagePropertiesCallback() { Callback callbackOne = mock(Callback.class); Callback callbackTwo = mock(PagePropertiesCallback.class); Callback callbackThree = mock(Callback.class); Callback[] callbacks = new Callback[]{callbackOne, callbackTwo, callbackThree}; given(authContext.getRequirements(true)).willReturn(callbacks); PagePropertiesCallback pagePropertiesCallback = loginProcess.getPagePropertiesCallback(); verify(authContext).getRequirements(true); assertEquals(pagePropertiesCallback, callbackTwo); }
|
### Question:
LoginProcess { public boolean isSuccessful() { return AuthContext.Status.SUCCESS.equals(authContext.getStatus()); } LoginProcess(LoginAuthenticator loginAuthenticator, LoginConfiguration loginConfiguration,
AuthContextLocalWrapper authContext, CoreServicesWrapper coreServicesWrapper); LoginStage getLoginStage(); Callback[] getCallbacks(); PagePropertiesCallback getPagePropertiesCallback(); LoginProcess next(Callback[] callbacks); boolean isSuccessful(); AuthContextLocalWrapper getAuthContext(); LoginConfiguration getLoginConfiguration(); }### Answer:
@Test public void shouldGetIsSuccessfulWhenAuthContextIsSuccess() { given(authContext.getStatus()).willReturn(AuthContext.Status.SUCCESS); boolean success = loginProcess.isSuccessful(); assertTrue(success); }
@Test public void shouldGetIsSuccessfulWhenAuthContextNotSuccess() { given(authContext.getStatus()).willReturn(AuthContext.Status.FAILED); boolean success = loginProcess.isSuccessful(); assertFalse(success); }
|
### Question:
LoginProcess { public AuthContextLocalWrapper getAuthContext() { return authContext; } LoginProcess(LoginAuthenticator loginAuthenticator, LoginConfiguration loginConfiguration,
AuthContextLocalWrapper authContext, CoreServicesWrapper coreServicesWrapper); LoginStage getLoginStage(); Callback[] getCallbacks(); PagePropertiesCallback getPagePropertiesCallback(); LoginProcess next(Callback[] callbacks); boolean isSuccessful(); AuthContextLocalWrapper getAuthContext(); LoginConfiguration getLoginConfiguration(); }### Answer:
@Test public void shouldGetAuthContext() { AuthContextLocalWrapper authContextLocalWrapper = loginProcess.getAuthContext(); assertEquals(authContextLocalWrapper, authContext); }
|
### Question:
LoginProcess { public LoginConfiguration getLoginConfiguration() { return loginConfiguration; } LoginProcess(LoginAuthenticator loginAuthenticator, LoginConfiguration loginConfiguration,
AuthContextLocalWrapper authContext, CoreServicesWrapper coreServicesWrapper); LoginStage getLoginStage(); Callback[] getCallbacks(); PagePropertiesCallback getPagePropertiesCallback(); LoginProcess next(Callback[] callbacks); boolean isSuccessful(); AuthContextLocalWrapper getAuthContext(); LoginConfiguration getLoginConfiguration(); }### Answer:
@Test public void shouldGetLoginConfiguration() { LoginConfiguration loginConfig = loginProcess.getLoginConfiguration(); assertEquals(loginConfig, loginConfiguration); }
|
### Question:
AuthIdHelper { public SignedJwt reconstructAuthId(String authId) { try { return jwtBuilderFactory.reconstruct(authId, SignedJwt.class); } catch (JwtRuntimeException e) { throw new RestAuthException(Response.Status.BAD_REQUEST, "Failed to parse JWT, " + e.getLocalizedMessage(), e); } } @Inject AuthIdHelper(CoreServicesWrapper coreServicesWrapper, AMKeyProvider amKeyProvider,
JwtBuilderFactory jwtBuilderFactory); String createAuthId(LoginConfiguration loginConfiguration, AuthenticationContext authContext); SignedJwt reconstructAuthId(String authId); void verifyAuthId(String realmDN, String authId); }### Answer:
@Test public void shouldReconstructAuthId() { authIdHelper.reconstructAuthId("AUTH_ID"); verify(jwtBuilderFactory).reconstruct("AUTH_ID", SignedJwt.class); }
@Test public void shouldThrowRestAuthExceptionWhenReconstructingAuthIdFails() { given(jwtBuilderFactory.reconstruct("AUTH_ID", SignedJwt.class)).willThrow(JwtRuntimeException.class); RestAuthException exception = null; boolean exceptionCaught = false; try { authIdHelper.reconstructAuthId("AUTH_ID"); fail(); } catch (RestAuthException e) { exception = e; exceptionCaught = true; } assertTrue(exceptionCaught); Response response = exception.getResponse(); assertEquals(response.getStatus(), 400); JsonValue jsonValue = JsonValueBuilder.toJsonValue((String) response.getEntity()); assertTrue(jsonValue.isDefined("errorMessage")); }
|
### Question:
RestAuthChoiceCallbackHandler extends AbstractRestAuthCallbackHandler<ChoiceCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } ChoiceCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, ChoiceCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(ChoiceCallback callback, int index); ChoiceCallback convertFromJson(ChoiceCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthChoiceCallbackHandler.getCallbackClassName(); assertEquals(ChoiceCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthChoiceCallbackHandler extends AbstractRestAuthCallbackHandler<ChoiceCallback> { public ChoiceCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, ChoiceCallback originalCallback) { return originalCallback; } ChoiceCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, ChoiceCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(ChoiceCallback callback, int index); ChoiceCallback convertFromJson(ChoiceCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); ChoiceCallback originalChoiceCallback = mock(ChoiceCallback.class); ChoiceCallback choiceCallback = restAuthChoiceCallbackHandler.handle(headers, request, response, jsonPostBody, originalChoiceCallback); assertEquals(originalChoiceCallback, choiceCallback); }
|
### Question:
RestAuthHttpCallbackHandler extends AbstractRestAuthCallbackHandler<HttpCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, HttpCallback callback); HttpCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, HttpCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(HttpCallback callback, int index); HttpCallback convertFromJson(HttpCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthHttpCallbackHandler.getCallbackClassName(); assertEquals(HttpCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthHttpCallbackHandler extends AbstractRestAuthCallbackHandler<HttpCallback> { public HttpCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, HttpCallback originalCallback) { if (isJsonAttributePresent(postBody, "reason") && postBody.get("reason").asString().equals(HTTP_AUTH_FAILED)) { request.setAttribute(HTTP_AUTH_FAILED, true); } return originalCallback; } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, HttpCallback callback); HttpCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, HttpCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(HttpCallback callback, int index); HttpCallback convertFromJson(HttpCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallbackAndSetHttpAuthFailedIfReasonInPostBody() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); HttpCallback originalHttpCallback = mock(HttpCallback.class); Map<String, String> postBodyMap = new LinkedHashMap<String, String>(); postBodyMap.put("reason", "http-auth-failed"); JsonValue jsonPostBody = new JsonValue(postBodyMap); HttpCallback httpCallback = restAuthHttpCallbackHandler.handle(headers, request, response, jsonPostBody, originalHttpCallback); assertEquals(originalHttpCallback, httpCallback); verify(request).setAttribute("http-auth-failed", true); }
@Test public void shouldHandleCallbackWhereIWASuccessful() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = new JsonValue(new HashMap<String, String>()); HttpCallback originalHttpCallback = mock(HttpCallback.class); HttpCallback httpCallback = restAuthHttpCallbackHandler.handle(headers, request, response, jsonPostBody, originalHttpCallback); assertEquals(originalHttpCallback, httpCallback); verify(request, never()).setAttribute("http-auth-failed", true); }
|
### Question:
RestAuthHttpCallbackHandler extends AbstractRestAuthCallbackHandler<HttpCallback> { public JsonValue convertToJson(HttpCallback callback, int index) { throw new RestAuthException(Response.Status.BAD_REQUEST, new UnsupportedOperationException( "HttpCallback Authorization Header must be specified in the initial request. Cannot be converted into" + " a JSON representation.")); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, HttpCallback callback); HttpCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, HttpCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(HttpCallback callback, int index); HttpCallback convertFromJson(HttpCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailConvertToJson() { restAuthHttpCallbackHandler.convertToJson(null, 1); fail(); }
|
### Question:
RestAuthHttpCallbackHandler extends AbstractRestAuthCallbackHandler<HttpCallback> { public HttpCallback convertFromJson(HttpCallback callback, JsonValue jsonCallback) { throw new RestAuthException(Response.Status.BAD_REQUEST, new UnsupportedOperationException( "HttpCallback Authorization Header must be specified in the initial request. Cannot be converted from" + " a JSON representation.")); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, HttpCallback callback); HttpCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, HttpCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(HttpCallback callback, int index); HttpCallback convertFromJson(HttpCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailToConvertFromJson() { restAuthHttpCallbackHandler.convertFromJson(null, null); fail(); }
|
### Question:
RestAuthRedirectCallbackHandler extends AbstractRestAuthCallbackHandler<RedirectCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } RestAuthRedirectCallbackHandler(RedirectCallbackHandler redirectCallbackHandler); boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, RedirectCallback callback); RedirectCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, RedirectCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(RedirectCallback callback, int index); RedirectCallback convertFromJson(RedirectCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthRedirectCallbackHandler.getCallbackClassName(); assertEquals(RedirectCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthRedirectCallbackHandler extends AbstractRestAuthCallbackHandler<RedirectCallback> { public RedirectCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, RedirectCallback originalCallback) { return originalCallback; } RestAuthRedirectCallbackHandler(RedirectCallbackHandler redirectCallbackHandler); boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, RedirectCallback callback); RedirectCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, RedirectCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(RedirectCallback callback, int index); RedirectCallback convertFromJson(RedirectCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); RedirectCallback originalRedirectCallback = mock(RedirectCallback.class); RedirectCallback redirectCallback = restAuthRedirectCallbackHandler.handle(headers, request, response, jsonPostBody, originalRedirectCallback); assertEquals(originalRedirectCallback, redirectCallback); }
|
### Question:
RestAuthRedirectCallbackHandler extends AbstractRestAuthCallbackHandler<RedirectCallback> { public JsonValue convertToJson(RedirectCallback callback, int index) { throw new RestAuthException(Response.Status.INTERNAL_SERVER_ERROR, new UnsupportedOperationException( "RedirectCallbacks cannot be converted to JSON")); } RestAuthRedirectCallbackHandler(RedirectCallbackHandler redirectCallbackHandler); boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, RedirectCallback callback); RedirectCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, RedirectCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(RedirectCallback callback, int index); RedirectCallback convertFromJson(RedirectCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailConvertToJson() { restAuthRedirectCallbackHandler.convertToJson(null, 1); fail(); }
|
### Question:
RestAuthRedirectCallbackHandler extends AbstractRestAuthCallbackHandler<RedirectCallback> { public RedirectCallback convertFromJson(RedirectCallback callback, JsonValue jsonCallback) { throw new RestAuthException(Response.Status.INTERNAL_SERVER_ERROR, new UnsupportedOperationException( "RedirectCallbacks cannot be converted from JSON")); } RestAuthRedirectCallbackHandler(RedirectCallbackHandler redirectCallbackHandler); boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, RedirectCallback callback); RedirectCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, RedirectCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(RedirectCallback callback, int index); RedirectCallback convertFromJson(RedirectCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailToConvertFromJson() { restAuthRedirectCallbackHandler.convertFromJson(null, null); fail(); }
|
### Question:
RestAuthPasswordCallbackHandler extends AbstractRestAuthCallbackHandler<PasswordCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } PasswordCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, PasswordCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(PasswordCallback callback, int index); PasswordCallback convertFromJson(PasswordCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthPasswordCallbackHandler.getCallbackClassName(); assertEquals(PasswordCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthPasswordCallbackHandler extends AbstractRestAuthCallbackHandler<PasswordCallback> { public PasswordCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, PasswordCallback originalCallback) { return originalCallback; } PasswordCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, PasswordCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(PasswordCallback callback, int index); PasswordCallback convertFromJson(PasswordCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); PasswordCallback originalPasswordCallback = mock(PasswordCallback.class); PasswordCallback passwordCallback = restAuthPasswordCallbackHandler.handle(headers, request, response, jsonPostBody, originalPasswordCallback); assertEquals(originalPasswordCallback, passwordCallback); }
|
### Question:
RestAuthPasswordCallbackHandler extends AbstractRestAuthCallbackHandler<PasswordCallback> { public JsonValue convertToJson(PasswordCallback callback, int index) { String prompt = callback.getPrompt(); JsonValue jsonValue = JsonValueBuilder.jsonValue() .put("type", CALLBACK_NAME) .array("output") .addLast(createOutputField("prompt", prompt)) .array("input") .addLast(createInputField(index, "")) .build(); return jsonValue; } PasswordCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, PasswordCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(PasswordCallback callback, int index); PasswordCallback convertFromJson(PasswordCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldConvertToJson() { PasswordCallback passwordCallback = new PasswordCallback("Enter password:", false); JsonValue jsonObject = restAuthPasswordCallbackHandler.convertToJson(passwordCallback, 1); assertEquals("PasswordCallback", jsonObject.get("type").asString()); assertNotNull(jsonObject.get("output")); Assert.assertEquals(1, jsonObject.get("output").size()); Assert.assertEquals("Enter password:", jsonObject.get("output").get(0).get("value").asString()); assertNotNull(jsonObject.get("input")); Assert.assertEquals(1, jsonObject.get("input").size()); Assert.assertEquals("", jsonObject.get("input").get(0).get("value").asString()); }
|
### Question:
AbstractRestAuthCallbackHandler implements RestAuthCallbackHandler<T> { final JsonValue createJsonField(String name, Object value) { return JsonValueBuilder.jsonValue() .put("name", name == null ? "" : name) .put("value", value == null ? "" : value) .build(); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, T callback); }### Answer:
@Test public void shouldCreateJsonField() { String name = "NAME"; String value = "VALUE"; JsonValue jsonObject = abstractRestAuthCallbackHandler.createJsonField(name, value); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").asString(), "VALUE"); }
@Test public void shouldCreateJsonFieldWithNullValue() throws JSONException { String name = "NAME"; String value = null; JsonValue jsonObject = abstractRestAuthCallbackHandler.createJsonField(name, value); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").asString(), ""); }
@Test public void shouldCreateJsonFieldWithObjectArray() { String name = "NAME"; String[] values = new String[]{"VALUE1", "VALUE2", "VALUE3"}; JsonValue jsonObject = abstractRestAuthCallbackHandler.createJsonField(name, values); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").get(0).asString(), "VALUE1"); assertEquals(jsonObject.get("value").get(1).asString(), "VALUE2"); assertEquals(jsonObject.get("value").get(2).asString(), "VALUE3"); }
@Test public void shouldCreateJsonFieldWithNullObjectArray() { String name = "NAME"; String[] values = null; JsonValue jsonObject = abstractRestAuthCallbackHandler.createJsonField(name, values); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").size(), 0); }
|
### Question:
AbstractRestAuthCallbackHandler implements RestAuthCallbackHandler<T> { final JsonValue createInputField(int index, Object value) { return createJsonField("IDToken" + index, value); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, T callback); }### Answer:
@Test public void shouldCreateJsonInputField() throws JSONException { String value = "VALUE"; JsonValue jsonObject = abstractRestAuthCallbackHandler.createInputField(0, value); assertEquals(jsonObject.get("name").asString(), "IDToken0"); assertEquals(jsonObject.get("value").asString(), "VALUE"); }
@Test public void shouldCreateJsonInputFieldWithObjectArray() throws JSONException { String[] values = new String[]{"VALUE1", "VALUE2", "VALUE3"}; JsonValue jsonObject = abstractRestAuthCallbackHandler.createInputField(0, values); assertEquals(jsonObject.get("name").asString(), "IDToken0"); assertEquals(jsonObject.get("value").get(0).asString(), "VALUE1"); assertEquals(jsonObject.get("value").get(1).asString(), "VALUE2"); assertEquals(jsonObject.get("value").get(2).asString(), "VALUE3"); }
|
### Question:
AbstractRestAuthCallbackHandler implements RestAuthCallbackHandler<T> { final JsonValue createOutputField(String name, Object value) { return createJsonField(name, value); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, T callback); }### Answer:
@Test public void shouldCreateJsonOutputField() throws JSONException { String name = "NAME"; String value = "VALUE"; JsonValue jsonObject = abstractRestAuthCallbackHandler.createOutputField(name, value); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").asString(), "VALUE"); }
@Test public void shouldCreateJsonOutputFieldWithObjectArray() throws JSONException { String name = "NAME"; String[] values = new String[]{"VALUE1", "VALUE2", "VALUE3"}; JsonValue jsonObject = abstractRestAuthCallbackHandler.createOutputField(name, values); assertEquals(jsonObject.get("name").asString(), "NAME"); assertEquals(jsonObject.get("value").get(0).asString(), "VALUE1"); assertEquals(jsonObject.get("value").get(1).asString(), "VALUE2"); assertEquals(jsonObject.get("value").get(2).asString(), "VALUE3"); }
|
### Question:
AbstractRestAuthCallbackHandler implements RestAuthCallbackHandler<T> { final void validateCallbackType(String callbackName, JsonValue jsonCallback) { String type = jsonCallback.get("type").asString(); if (!callbackName.equalsIgnoreCase(type)) { DEBUG.message(MessageFormat.format("Method called with invalid callback, {0}.", type)); throw new RestAuthException(Response.Status.BAD_REQUEST, MessageFormat.format("Invalid Callback, {0}, for handler", type)); } } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, T callback); }### Answer:
@Test public void shouldValidateCallbackTypeSuccessfully() throws JSONException { String callbackName = "CALLBACK_NAME"; JsonValue jsonCallback = mock(JsonValue.class); JsonValue typeJson = mock(JsonValue.class); given(jsonCallback.get("type")).willReturn(typeJson); given(typeJson.asString()).willReturn("CALLBACK_NAME"); abstractRestAuthCallbackHandler.validateCallbackType(callbackName, jsonCallback); }
@Test (expectedExceptions = RestAuthException.class) public void shouldValidateCallbackTypeUnsuccessfully() throws JSONException { String callbackName = "CALLBACK_NAME"; JsonValue jsonCallback = mock(JsonValue.class); JsonValue typeJson = mock(JsonValue.class); given(jsonCallback.get("type")).willReturn(typeJson); given(typeJson.asString()).willReturn("CALLBACK_NAME_NOT"); abstractRestAuthCallbackHandler.validateCallbackType(callbackName, jsonCallback); fail(); }
|
### Question:
AbstractRestAuthCallbackHandler implements RestAuthCallbackHandler<T> { boolean isJsonAttributePresent(JsonValue jsonObject, String attributeName) { if (jsonObject.get(attributeName).isNull()) { return false; } return true; } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, T callback); }### Answer:
@Test public void shouldCheckIfJsonAttributePresentWithTrue() throws JSONException { String attributeName = "ATTRIBUTE_NAME"; Map<String, String> map = new LinkedHashMap<String, String>(); map.put("ATTRIBUTE_NAME", "VALUE"); JsonValue jsonObject = new JsonValue(map); boolean isAttributePresent = abstractRestAuthCallbackHandler.isJsonAttributePresent(jsonObject, attributeName); assertTrue(isAttributePresent); }
@Test public void shouldCheckIfJsonAttributePresentWithFalse() throws JSONException { String attributeName = "ATTRIBUTE_NAME"; Map<String, String> map = new LinkedHashMap<String, String>(); map.put("OTHER_ATTRIBUTE_NAME", "VALUE"); JsonValue jsonObject = new JsonValue(map); boolean isAttributePresent = abstractRestAuthCallbackHandler.isJsonAttributePresent(jsonObject, attributeName); assertFalse(isAttributePresent); }
|
### Question:
RestAuthConfirmationCallbackHandler extends AbstractRestAuthCallbackHandler<ConfirmationCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } ConfirmationCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, ConfirmationCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(ConfirmationCallback callback, int index); ConfirmationCallback convertFromJson(ConfirmationCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthConfirmationCallbackHandler.getCallbackClassName(); assertEquals(ConfirmationCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthConfirmationCallbackHandler extends AbstractRestAuthCallbackHandler<ConfirmationCallback> { public ConfirmationCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, ConfirmationCallback originalCallback) { return originalCallback; } ConfirmationCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, ConfirmationCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(ConfirmationCallback callback, int index); ConfirmationCallback convertFromJson(ConfirmationCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); ConfirmationCallback originalConfirmationCallback = mock(ConfirmationCallback.class); ConfirmationCallback confirmationCallback = restAuthConfirmationCallbackHandler.handle(headers, request, response, jsonPostBody, originalConfirmationCallback); assertEquals(originalConfirmationCallback, confirmationCallback); }
|
### Question:
RestAuthLanguageCallbackHandler extends AbstractRestAuthCallbackHandler<LanguageCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } LanguageCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, LanguageCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(LanguageCallback callback, int index); LanguageCallback convertFromJson(LanguageCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthLanguageCallbackHandler.getCallbackClassName(); assertEquals(LanguageCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthLanguageCallbackHandler extends AbstractRestAuthCallbackHandler<LanguageCallback> { public JsonValue convertToJson(LanguageCallback callback, int index) { Locale locale = callback.getLocale(); JsonObject jsonObject = JsonValueBuilder.jsonValue() .put("type", CALLBACK_NAME); if (locale != null) { jsonObject.array("input") .add(createInputField(index, "Language", locale.getLanguage())) .addLast(createInputField(index, "Country", locale.getCountry())); } return jsonObject.build(); } LanguageCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, LanguageCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(LanguageCallback callback, int index); LanguageCallback convertFromJson(LanguageCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldConvertToJsonWhenLocaleNotSet() { LanguageCallback languageCallback = new LanguageCallback(); JsonValue jsonObject = restAuthLanguageCallbackHandler.convertToJson(languageCallback, 1); assertEquals(1, jsonObject.size()); assertEquals("LanguageCallback", jsonObject.get("type").asString()); }
@Test public void shouldConvertToJson() { LanguageCallback languageCallback = new LanguageCallback(); languageCallback.setLocale(new Locale("LANGUAGE", "COUNTRY")); JsonValue jsonObject = restAuthLanguageCallbackHandler.convertToJson(languageCallback, 1); assertEquals(2, jsonObject.size()); assertEquals("LanguageCallback", jsonObject.get("type").asString()); assertNotNull(jsonObject.get("input")); assertEquals(2, jsonObject.get("input").size()); assertEquals("language", jsonObject.get("input").get(0).get("value").asString()); assertEquals("COUNTRY", jsonObject.get("input").get(1).get("value").asString()); }
|
### Question:
RestAuthLanguageCallbackHandler extends AbstractRestAuthCallbackHandler<LanguageCallback> { public LanguageCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, LanguageCallback originalCallback) { return originalCallback; } LanguageCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, LanguageCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(LanguageCallback callback, int index); LanguageCallback convertFromJson(LanguageCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); LanguageCallback originalLanguageCallback = mock(LanguageCallback.class); LanguageCallback languageCallback = restAuthLanguageCallbackHandler.handle(headers, request, response, jsonPostBody, originalLanguageCallback); assertEquals(originalLanguageCallback, languageCallback); }
|
### Question:
RestAuthX509CallbackHandler extends AbstractRestAuthCallbackHandler<X509CertificateCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, X509CertificateCallback callback); X509CertificateCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, X509CertificateCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(X509CertificateCallback callback, int index); X509CertificateCallback convertFromJson(X509CertificateCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthX509CallbackHandler.getCallbackClassName(); assertEquals(X509CertificateCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthX509CallbackHandler extends AbstractRestAuthCallbackHandler<X509CertificateCallback> { public X509CertificateCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, X509CertificateCallback originalCallback) { return originalCallback; } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, X509CertificateCallback callback); X509CertificateCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, X509CertificateCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(X509CertificateCallback callback, int index); X509CertificateCallback convertFromJson(X509CertificateCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); X509CertificateCallback originalX509CertificateCallback = mock(X509CertificateCallback.class); X509CertificateCallback x509CertificateCallback = restAuthX509CallbackHandler.handle(headers, request, response, jsonPostBody, originalX509CertificateCallback); assertEquals(originalX509CertificateCallback, x509CertificateCallback); }
|
### Question:
RestAuthX509CallbackHandler extends AbstractRestAuthCallbackHandler<X509CertificateCallback> { public JsonValue convertToJson(X509CertificateCallback callback, int index) { throw new RestAuthException(Response.Status.BAD_REQUEST, new UnsupportedOperationException( "X509Certificate must be specified in the initial request. Cannot be converted into a JSON " + "representation.")); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, X509CertificateCallback callback); X509CertificateCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, X509CertificateCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(X509CertificateCallback callback, int index); X509CertificateCallback convertFromJson(X509CertificateCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailConvertToJson() { restAuthX509CallbackHandler.convertToJson(null, 1); fail(); }
|
### Question:
RestAuthX509CallbackHandler extends AbstractRestAuthCallbackHandler<X509CertificateCallback> { public X509CertificateCallback convertFromJson(X509CertificateCallback callback, JsonValue jsonCallback) { throw new RestAuthException(Response.Status.BAD_REQUEST, new UnsupportedOperationException( "X509Certificate must be specified in the initial request. Cannot be converted from a JSON " + "representation.")); } boolean updateCallbackFromRequest(HttpHeaders headers, HttpServletRequest request,
HttpServletResponse response, X509CertificateCallback callback); X509CertificateCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, X509CertificateCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(X509CertificateCallback callback, int index); X509CertificateCallback convertFromJson(X509CertificateCallback callback, JsonValue jsonCallback); }### Answer:
@Test (expectedExceptions = RestAuthException.class) public void shouldFailToConvertFromJson() { restAuthX509CallbackHandler.convertFromJson(null, null); fail(); }
|
### Question:
RestAuthNameCallbackHandler extends AbstractRestAuthCallbackHandler<NameCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } String getCallbackClassName(); NameCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, NameCallback originalCallback); JsonValue convertToJson(NameCallback callback, int index); NameCallback convertFromJson(NameCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthNameCallbackHandler.getCallbackClassName(); assertEquals(NameCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthNameCallbackHandler extends AbstractRestAuthCallbackHandler<NameCallback> { public NameCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, NameCallback originalCallback) { return originalCallback; } String getCallbackClassName(); NameCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, NameCallback originalCallback); JsonValue convertToJson(NameCallback callback, int index); NameCallback convertFromJson(NameCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); NameCallback originalNameCallback = mock(NameCallback.class); NameCallback nameCallback = restAuthNameCallbackHandler.handle(headers, request, response, jsonPostBody, originalNameCallback); assertEquals(originalNameCallback, nameCallback); }
|
### Question:
RestAuthNameCallbackHandler extends AbstractRestAuthCallbackHandler<NameCallback> { public JsonValue convertToJson(NameCallback callback, int index) { String prompt = callback.getPrompt(); String name = callback.getName(); JsonValue jsonValue = JsonValueBuilder.jsonValue() .put("type", CALLBACK_NAME) .array("output") .addLast(createOutputField("prompt", prompt)) .array("input") .addLast(createInputField(index, name)) .build(); return jsonValue; } String getCallbackClassName(); NameCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, NameCallback originalCallback); JsonValue convertToJson(NameCallback callback, int index); NameCallback convertFromJson(NameCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldConvertToJson() { NameCallback nameCallback = new NameCallback("Enter username:"); JsonValue jsonObject = restAuthNameCallbackHandler.convertToJson(nameCallback, 1); assertEquals("NameCallback", jsonObject.get("type").asString()); assertNotNull(jsonObject.get("output")); Assert.assertEquals(1, jsonObject.get("output").size()); Assert.assertEquals("Enter username:", jsonObject.get("output").get(0).get("value").asString()); assertNotNull(jsonObject.get("input")); Assert.assertEquals(1, jsonObject.get("input").size()); Assert.assertEquals("", jsonObject.get("input").get(0).get("value").asString()); }
|
### Question:
RestAuthTextInputCallbackHandler extends AbstractRestAuthCallbackHandler<TextInputCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } TextInputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextInputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextInputCallback callback, int index); TextInputCallback convertFromJson(TextInputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = restAuthTextInputCallbackHandler.getCallbackClassName(); assertEquals(TextInputCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthTextInputCallbackHandler extends AbstractRestAuthCallbackHandler<TextInputCallback> { public TextInputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, TextInputCallback originalCallback) { return originalCallback; } TextInputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextInputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextInputCallback callback, int index); TextInputCallback convertFromJson(TextInputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); TextInputCallback originalTextInputCallback = mock(TextInputCallback.class); TextInputCallback textInputCallback = restAuthTextInputCallbackHandler.handle(headers, request, response, jsonPostBody, originalTextInputCallback); assertEquals(originalTextInputCallback, textInputCallback); }
|
### Question:
RestAuthTextInputCallbackHandler extends AbstractRestAuthCallbackHandler<TextInputCallback> { public JsonValue convertToJson(TextInputCallback callback, int index) { String prompt = callback.getPrompt(); String defaultText = callback.getDefaultText(); String text = callback.getText(); JsonValue jsonValue = JsonValueBuilder.jsonValue() .put("type", CALLBACK_NAME) .array("output") .add(createOutputField("prompt", prompt)) .addLast(createOutputField("defaultText", defaultText)) .array("input") .addLast(createInputField(index, text)) .build(); return jsonValue; } TextInputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextInputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextInputCallback callback, int index); TextInputCallback convertFromJson(TextInputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldConvertToJson() { TextInputCallback textInputCallback = new TextInputCallback("Enter text:", "DEFAULT_VALUE"); JsonValue jsonObject = restAuthTextInputCallbackHandler.convertToJson(textInputCallback, 1); assertEquals("TextInputCallback", jsonObject.get("type").asString()); assertNotNull(jsonObject.get("output")); assertEquals(2, jsonObject.get("output").size()); assertEquals("Enter text:", jsonObject.get("output").get(0).get("value").asString()); assertEquals("DEFAULT_VALUE", jsonObject.get("output").get(1).get("value").asString()); assertNotNull(jsonObject.get("input")); assertEquals(1, jsonObject.get("input").size()); assertEquals("", jsonObject.get("input").get(0).get("value").asString()); }
|
### Question:
RestAuthTextOutputCallbackHandler extends AbstractRestAuthCallbackHandler<TextOutputCallback> { public String getCallbackClassName() { return CALLBACK_NAME; } TextOutputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextOutputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextOutputCallback callback, int index); TextOutputCallback convertFromJson(TextOutputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldGetCallbackClassName() { String callbackClassName = testOutputRestAuthCallbackHandler.getCallbackClassName(); assertEquals(TextOutputCallback.class.getSimpleName(), callbackClassName); }
|
### Question:
RestAuthTextOutputCallbackHandler extends AbstractRestAuthCallbackHandler<TextOutputCallback> { public TextOutputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response, JsonValue postBody, TextOutputCallback originalCallback) { return originalCallback; } TextOutputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextOutputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextOutputCallback callback, int index); TextOutputCallback convertFromJson(TextOutputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldHandleCallback() { HttpHeaders headers = mock(HttpHeaders.class); HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); JsonValue jsonPostBody = mock(JsonValue.class); TextOutputCallback originalTextOutputCallback = mock(TextOutputCallback.class); TextOutputCallback textOutputCallback = testOutputRestAuthCallbackHandler.handle(headers, request, response, jsonPostBody, originalTextOutputCallback); assertEquals(originalTextOutputCallback, textOutputCallback); }
|
### Question:
RestAuthTextOutputCallbackHandler extends AbstractRestAuthCallbackHandler<TextOutputCallback> { public JsonValue convertToJson(TextOutputCallback callback, int index) { String message = callback.getMessage(); int messageType = callback.getMessageType(); JsonValue jsonValue = JsonValueBuilder.jsonValue() .put("type", CALLBACK_NAME) .array("output") .add(createOutputField("message", message)) .addLast(createOutputField("messageType", messageType)) .build(); return jsonValue; } TextOutputCallback handle(HttpHeaders headers, HttpServletRequest request, HttpServletResponse response,
JsonValue postBody, TextOutputCallback originalCallback); String getCallbackClassName(); JsonValue convertToJson(TextOutputCallback callback, int index); TextOutputCallback convertFromJson(TextOutputCallback callback, JsonValue jsonCallback); }### Answer:
@Test public void shouldConvertToJson() { TextOutputCallback textOutputCallback = new TextOutputCallback(TextOutputCallback.INFORMATION, "MESSAGE"); JsonValue jsonObject = testOutputRestAuthCallbackHandler.convertToJson(textOutputCallback, 1); assertEquals("TextOutputCallback", jsonObject.get("type").asString()); assertNotNull(jsonObject.get("output")); assertEquals(2, jsonObject.get("output").size()); assertEquals("MESSAGE", jsonObject.get("output").get(0).get("value").asString()); assertEquals(TextOutputCallback.INFORMATION, (int) jsonObject.get("output").get(1).get("value").asInteger()); assertEquals(2, jsonObject.size()); }
|
### Question:
RestAuthService extends Application { @Override public Set<Class<?>> getClasses() { Set<Class<?>> classes = new HashSet<Class<?>>(); classes.add(AuthenticationRestService.class); return classes; } @Override Set<Class<?>> getClasses(); }### Answer:
@Test public void shouldGetClasses() { RestAuthService restAuthService = new RestAuthService(); Set<Class<?>> classes = restAuthService.getClasses(); assertEquals(classes.size(), 1); assertTrue(classes.contains(AuthenticationRestService.class)); }
|
### Question:
MailServerImpl implements MailServer { public void sendEmail(String to, String subject, String message) throws MessagingException{ sendEmail(null,to, subject, message, null); } MailServerImpl(String realm); MailServerImpl(ServiceConfigManager mgr, ServiceConfig scm, Debug debug, AMSendMail sendMail,
Map<String, Set<String>> options); String getSubject(); String getMessage(); void sendEmail(String to, String subject, String message); void sendEmail(String from, String to, String subject,
String message, Map options); final static public String SERVICE_NAME; final static public String SERVICE_VERSION; }### Answer:
@Test public void testSendMailWithoutOptions(){ try { mailServerMock.sendEmail("[email protected]", "Subject", "Message"); verify(sendMailMock, times(1)).postMail(eq(recipients), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyBoolean()); } catch (MessagingException e){ assert(false); } }
@Test public void testSendMailWithOptions(){ try { mailServerMock.sendEmail("[email protected]", "[email protected]", "Subject", "Message", createOptionsMap()); verify(sendMailMock, times(1)).postMail(eq(recipients), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyBoolean()); } catch (MessagingException e){ assert(false); } }
|
### Question:
TokenDeletion implements Closeable { public void deleteBatch(Collection<Entry> entries, ResultHandler<Result> resultHandler) throws ErrorResultException { for (Entry entry : entries) { String tokenId = entry.getAttribute(CoreTokenField.TOKEN_ID.toString()).firstValueAsString(); adapter.deleteAsync(getConnection(), tokenId, resultHandler); } } @Inject TokenDeletion(LDAPAdapter adapter, ConnectionFactory factory); void deleteBatch(Collection<Entry> entries, ResultHandler<Result> resultHandler); void close(); }### Answer:
@Test public void shouldDeleteEntries() throws ErrorResultException { Collection<Entry> entries = Arrays.asList( generateEntry("one"),generateEntry("two"),generateEntry("three")); deletion.deleteBatch(entries, mock(ResultHandler.class)); verify(mockAdapter, times(3)).deleteAsync( eq(mockConnection), anyString(), any(ResultHandler.class)); }
|
### Question:
CoreTokenConfigListener implements ConfigurationListener { public void notifyChanges() { ldapConfig.update(); externalTokenConfig.update(); connectionFactory.updateConnection(); } @Inject CoreTokenConfigListener(LDAPConfig ldapConfig, ExternalTokenConfig externalTokenConfig,
CTSConnectionFactory connectionFactory); void notifyChanges(); }### Answer:
@Test public void shouldCallBothConfigurations() { listener.notifyChanges(); verify(mockLDAPConfig).update(); verify(mockExternalConfig).update(); }
@Test public void shouldCallConnectionFactory() { listener.notifyChanges(); verify(mockFactory).updateConnection(); }
|
### Question:
SessionAdapter implements TokenAdapter<InternalSession> { public InternalSession fromToken(Token token) { String jsonBlob = blobUtils.getBlobAsString(token); int index = findIndexOfValidField(jsonBlob); String latestAccessTime = token.getValue(SessionTokenField.LATEST_ACCESS_TIME.getField()); if (latestAccessTime != null && index != -1) { String fieldName = SessionTokenField.LATEST_ACCESS_TIME.getInternalSessionFieldName(); String jsonField = JSONSerialisation.jsonAttributeName(fieldName); String addition = jsonField + latestAccessTime + ","; jsonBlob = jsonBlob.substring(0, index) + addition + jsonBlob.substring(index, jsonBlob.length()); } return serialisation.deserialise(jsonBlob, InternalSession.class); } @Inject SessionAdapter(TokenIdFactory tokenIdFactory, CoreTokenConfig config,
JSONSerialisation serialisation, LDAPDataConversion dataConversion,
TokenBlobUtils blobUtils); Token toToken(InternalSession session); InternalSession fromToken(Token token); int findIndexOfValidField(String blob); String filterLatestAccessTime(Token token); }### Answer:
@Test public void shouldRestoreLatestAccessTimeFromAttribute() { String latestAccessTime = "12345"; Token token = new Token("badger", TokenType.SESSION); token.setAttribute(SessionTokenField.LATEST_ACCESS_TIME.getField(), latestAccessTime); token.setBlob("{\"clientDomain\":null,\"creationTime\":1376307674,\"isISStored\":true,\"maxCachingTime\":3}".getBytes()); JSONSerialisation serialisation = new JSONSerialisation(); adapter = new SessionAdapter(tokenIdFactory, coreTokenConfig, serialisation, ldapDataConversion, blobUtils); InternalSession session = adapter.fromToken(token); long epochedSeconds = System.currentTimeMillis() / 1000; long idleTime = session.getIdleTime(); assertTrue(idleTime < epochedSeconds); }
|
### Question:
HelloEJB { public String sayHelloEJB(String name) { return "Hello " + name; } String sayHelloEJB(String name); }### Answer:
@Test public void testHelloEJB() { String result = helloEJB.sayHelloEJB("Michael"); assertEquals("Hello Michael", result); }
|
### Question:
ValueCountResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ValueCountResult)) { return false; } ValueCountResult rhs = (ValueCountResult) obj; return new EqualsBuilder() .append(this.value, rhs.value) .append(this.count, rhs.count) .isEquals(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { ValueCountResult result1 = ValueCountResult.create(33, 5); ValueCountResult result2 = ValueCountResult.create(33, 5); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new ValueCountResult()).equals(0); assertFalse(e); }
|
### Question:
FieldRow { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FieldRow)) { return false; } FieldRow rhs = (FieldRow) obj; return new EqualsBuilder() .append(this.fieldName, rhs.fieldName) .append(this.rowID, rhs.rowID) .append(this.rowKey, rhs.rowKey) .isEquals(); } private FieldRow(String fieldName, long rowID, String rowKey); static FieldRow create(String fieldName, long rowID); static FieldRow create(String fieldName, String rowKey); String getFieldName(); long getRowID(); String getRowKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { FieldRow f = FieldRow.create("f1", 42); assertTrue(f.equals(f)); assertFalse(f.equals(new Integer(42))); }
|
### Question:
FieldRow { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.fieldName) .append(this.rowID) .append(this.rowKey) .toHashCode(); } private FieldRow(String fieldName, long rowID, String rowKey); static FieldRow create(String fieldName, long rowID); static FieldRow create(String fieldName, String rowKey); String getFieldName(); long getRowID(); String getRowKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHashCode() { FieldRow f1 = FieldRow.create("f1", 42); FieldRow f2 = FieldRow.create("f1", 42); assertEquals(f1.hashCode(), f2.hashCode()); }
|
### Question:
PilosaClient implements AutoCloseable { @SuppressWarnings("WeakerAccess") public static PilosaClient defaultClient() { return PilosaClient.withURI(URI.defaultURI()); } protected PilosaClient(Cluster cluster, ClientOptions options); protected PilosaClient(URI uri, ClientOptions options); @SuppressWarnings("WeakerAccess") static PilosaClient defaultClient(); static PilosaClient withAddress(String address); static PilosaClient withURI(URI uri); static PilosaClient withURI(URI uri, ClientOptions options); static PilosaClient withCluster(Cluster cluster); @SuppressWarnings("WeakerAccess") static PilosaClient withCluster(Cluster cluster, ClientOptions options); void close(); QueryResponse query(PqlQuery query); QueryResponse query(PqlQuery query, QueryOptions options); void createIndex(Index index); void ensureIndex(Index index); void createField(Field field); void ensureField(Field field); void deleteIndex(Index index); void deleteField(Field field); void importField(Field field, RecordIterator iterator); @SuppressWarnings("WeakerAccess") void importField(Field field, RecordIterator iterator, ImportOptions options); @SuppressWarnings("WeakerAccess") void importField(Field field, RecordIterator iterator, ImportOptions options, final BlockingQueue<ImportStatusUpdate> statusQueue); SchemaInfo readServerSchema(); Schema readSchema(); void syncSchema(Schema schema); long[] translateRowKeys(Field field, String[] keys); long[] translateColumnKeys(Index index, String[] keys); long[] translateKeys(Internal.TranslateKeysRequest request); CloseableHttpResponse httpRequest(final String method, final String path); CloseableHttpResponse httpRequest(final String method, final String path, final ByteArrayEntity data,
Header[] headers); static String PQL_VERSION; }### Answer:
@Test public void defaultClientTest() throws IOException { try (PilosaClient client = PilosaClient.defaultClient()) { assertNotNull(client); } }
|
### Question:
FieldMeta { @JsonProperty("cacheType") void setCacheType(String s) { try { this.cacheType = CacheType.fromString(s); } catch (ValidationException ex) { } } }### Answer:
@Test public void testFieldMeta() { FieldMeta meta = new FieldMeta(); meta.setCacheType("foo"); }
|
### Question:
Column implements Record { @Override public int hashCode() { if (this.defaultColumn) { return new HashCodeBuilder(31, 47).append(true).toHashCode(); } return new HashCodeBuilder(31, 47) .append(this.rowID) .append(this.columnID) .append(this.rowKey) .append(this.columnKey) .append(this.timestamp) .toHashCode(); } private Column(); static Column create(long rowID, long columnID); static Column create(long rowID, long columnID, long timestamp); static Column create(long rowID, String columnKey); static Column create(long rowID, String columnKey, long timestamp); static Column create(String rowKey, long columnID); static Column create(String rowKey, long columnID, long timestamp); static Column create(String rowKey, String columnKey); static Column create(String rowKey, String columnKey, long timestamp); static Column create(boolean rowBool, long columnID); static Column create(boolean rowBool, long columnID, long timestamp); static Column create(boolean rowBool, String columnKey); static Column create(boolean rowBool, String columnKey, long timestamp); long getRowID(); String getRowKey(); boolean getRowBool(); long getColumnID(); String getColumnKey(); long getTimestamp(); @Override long shard(long shardWidth); @Override int compareTo(Record other); @Override boolean isDefault(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Column DEFAULT; }### Answer:
@Test public void hashCodeTest() { Column column1 = Column.create(1, 10, 65000); Column column2 = Column.create(1, 10, 65000); assertEquals(column1.hashCode(), column2.hashCode()); assertNotEquals(column1.hashCode(), Column.DEFAULT.hashCode()); }
|
### Question:
Column implements Record { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Column)) { return false; } Column column = (Column) o; return this.defaultColumn == column.defaultColumn && this.rowID == column.rowID && this.columnID == column.columnID && this.rowKey.equals(column.rowKey) && this.columnKey.equals(column.columnKey) && this.timestamp == column.timestamp; } private Column(); static Column create(long rowID, long columnID); static Column create(long rowID, long columnID, long timestamp); static Column create(long rowID, String columnKey); static Column create(long rowID, String columnKey, long timestamp); static Column create(String rowKey, long columnID); static Column create(String rowKey, long columnID, long timestamp); static Column create(String rowKey, String columnKey); static Column create(String rowKey, String columnKey, long timestamp); static Column create(boolean rowBool, long columnID); static Column create(boolean rowBool, long columnID, long timestamp); static Column create(boolean rowBool, String columnKey); static Column create(boolean rowBool, String columnKey, long timestamp); long getRowID(); String getRowKey(); boolean getRowBool(); long getColumnID(); String getColumnKey(); long getTimestamp(); @Override long shard(long shardWidth); @Override int compareTo(Record other); @Override boolean isDefault(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Column DEFAULT; }### Answer:
@Test public void equalsTest() { Column a = Column.create(5, 7, 100000); Column b = Column.create(5, 7, 100000); assertEquals(a, b); }
|
### Question:
Column implements Record { @Override public String toString() { if (this.defaultColumn) { return "(default column)"; } return String.format("%d:%d %s:%s [%d]", this.rowID, this.columnID, this.rowKey, this.columnKey, this.timestamp); } private Column(); static Column create(long rowID, long columnID); static Column create(long rowID, long columnID, long timestamp); static Column create(long rowID, String columnKey); static Column create(long rowID, String columnKey, long timestamp); static Column create(String rowKey, long columnID); static Column create(String rowKey, long columnID, long timestamp); static Column create(String rowKey, String columnKey); static Column create(String rowKey, String columnKey, long timestamp); static Column create(boolean rowBool, long columnID); static Column create(boolean rowBool, long columnID, long timestamp); static Column create(boolean rowBool, String columnKey); static Column create(boolean rowBool, String columnKey, long timestamp); long getRowID(); String getRowKey(); boolean getRowBool(); long getColumnID(); String getColumnKey(); long getTimestamp(); @Override long shard(long shardWidth); @Override int compareTo(Record other); @Override boolean isDefault(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Column DEFAULT; }### Answer:
@Test public void toStringTest() { Column column = Column.create(15, 2, 50000); assertEquals("15:2 : [50000]", column.toString()); assertEquals("(default column)", Column.DEFAULT.toString()); }
|
### Question:
ColumnItem { @Override public String toString() { return String.format("ColumnItem(id=%d, attrs=%s)", this.id, this.attributes); } ColumnItem(); ColumnItem(long id, Map<String, Object> attributes); long getID(); Map<String, Object> getAttributes(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testRowResultToString() { ColumnItem result = createSampleProfileItem(); String s = result.toString(); assertEquals("ColumnItem(id=33, attrs={city=Austin})", s); }
|
### Question:
ColumnItem { @Override public boolean equals(Object obj) { if (!(obj instanceof ColumnItem)) { return false; } if (obj == this) { return true; } ColumnItem rhs = (ColumnItem) obj; return new EqualsBuilder() .append(this.id, rhs.id) .append(this.attributes, rhs.attributes) .isEquals(); } ColumnItem(); ColumnItem(long id, Map<String, Object> attributes); long getID(); Map<String, Object> getAttributes(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testEquals() { ColumnItem result1 = createSampleProfileItem(); ColumnItem result2 = createSampleProfileItem(); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new ColumnItem(1, null)).equals(0); assertFalse(e); }
|
### Question:
ColumnItem { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.id) .append(this.attributes) .toHashCode(); } ColumnItem(); ColumnItem(long id, Map<String, Object> attributes); long getID(); Map<String, Object> getAttributes(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testHashCode() { ColumnItem result1 = createSampleProfileItem(); ColumnItem result2 = createSampleProfileItem(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
### Question:
NullResult implements QueryResult { static NullResult defaultResult() { return defaultResult; } private NullResult(); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); }### Answer:
@Test public void testEquals() { NullResult result1 = NullResult.defaultResult(); NullResult result2 = NullResult.defaultResult(); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (NullResult.defaultResult()).equals(0); assertFalse(e); }
@Test public void testHashCode() { NullResult result1 = NullResult.defaultResult(); NullResult result2 = NullResult.defaultResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
### Question:
GroupCount { private GroupCount(List<FieldRow> groups, long count) { this.groups = groups; this.count = count; } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGroupCount() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g = GroupCount.create(groups, 10); assertEquals(Collections.singletonList(FieldRow.create("f1", 42)), g.getGroups()); assertEquals(10, g.getCount()); assertEquals("GroupCount(groups=[FieldRow(field=f1, rowID=42, rowKey=)], count=10)", g.toString()); }
|
### Question:
GroupCount { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof GroupCount)) { return false; } GroupCount rhs = (GroupCount) obj; return new EqualsBuilder() .append(this.groups, rhs.groups) .append(this.count, rhs.count) .isEquals(); } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g = GroupCount.create(groups, 10); assertTrue(g.equals(g)); assertFalse(g.equals(new Integer(10))); }
|
### Question:
GroupCount { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.groups) .append(this.count) .toHashCode(); } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHashCode() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g1 = GroupCount.create(groups, 10); GroupCount g2 = GroupCount.create(groups, 10); assertEquals(g1.hashCode(), g2.hashCode()); }
|
### Question:
BoolResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BoolResult)) { return false; } return this.changed == ((BoolResult) obj).changed; } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { BoolResult result1 = BoolResult.create(true); BoolResult result2 = BoolResult.create(true); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new BoolResult()).equals(0); assertFalse(e); }
|
### Question:
BoolResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.changed) .toHashCode(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashCode() { BoolResult result1 = BoolResult.create(false); BoolResult result2 = BoolResult.create(false); assertEquals(result1.hashCode(), result2.hashCode()); }
|
### Question:
TopNResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TopNResult)) { return false; } TopNResult rhs = (TopNResult) obj; return new EqualsBuilder() .append(this.items, rhs.items) .isEquals(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { TopNResult result1 = createSampleResult(); TopNResult result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new TopNResult()).equals(0); assertFalse(e); }
|
### Question:
ValueCountResult implements QueryResult { static ValueCountResult create(long sum, long count) { ValueCountResult result = new ValueCountResult(); result.value = sum; result.count = count; return result; } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEqualsSameObject() { ValueCountResult result = ValueCountResult.create(6, 3); assertEquals(result, result); }
|
### Question:
TopNResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.items) .toHashCode(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashCode() { TopNResult result1 = createSampleResult(); TopNResult result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
### Question:
Validator { public static void ensureValidIndexName(String indexName) { if (!validIndexName(indexName)) { throw new ValidationException(String.format("Invalid index name: %s", indexName)); } } Validator(); @SuppressWarnings("WeakerAccess") static boolean validIndexName(String indexName); static void ensureValidIndexName(String indexName); @SuppressWarnings("WeakerAccess") static boolean validFieldName(String fieldName); static void ensureValidFieldName(String fieldName); @SuppressWarnings("WeakerAccess") static boolean validLabel(String label); static void ensureValidLabel(String label); @SuppressWarnings("WeakerAccess") static boolean validKey(String key); static void ensureValidKey(String key); }### Answer:
@Test public void ensureValidIndexNameTest() { String[] validIndexNames = new String[]{ "a", "ab", "ab1", "b-c", "d_e", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }; for (String name : validIndexNames) { Validator.ensureValidIndexName(name); } }
@Test public void ensureValidIndexNameFailsTest() { String[] invalidIndexNames = new String[]{ "", "'", "^", "/", "\\", "A", "*", "a:b", "valid?no", "yüce", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", "1", "_", "-", }; for (String name : invalidIndexNames) { try { Validator.ensureValidIndexName(name); } catch (ValidationException ex) { continue; } fail("Index name validation should have failed for: " + name); } }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.