method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Frequency { @Override public String toString() { return "Frequency{value=" + value + '}'; } private Frequency(int value); @CheckResult static Frequency of(@IntRange(from = LOWER, to = UPPER) int value); @CheckResult Frequency plus(@Nullable Frequency frequency); @CheckResult Frequency plus(int value); @CheckResult Frequency minus(@Nullable Frequency frequency); @CheckResult Frequency minus(int value); boolean isLimited(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Frequency MAX; static final Frequency MIN; final int value; }### Answer:
@Test public void toStringTest() { String s = Frequency.of(1).toString(); } |
### Question:
UriBuilder { public APIConnection build() throws APIKeyNotAssignedException { buildFinalURLWithCommandString(); buildFinalURLWithTheAPIKey(); buildFinalURLWithParametersToken(); return new APIConnection(finalURL); } UriBuilder(String baseURL); APIConnection build(); String getFinalURL(); UriBuilder setCommand(String commandString); UriBuilder setAPIKey(String apiKey, String apiKeyValue); void addUrlParameter(String key, String value); UriBuilder setParamStart(String paramStart); UriBuilder setApiKeyIsRequired(boolean apiKeyIsRequired); UriBuilder setNoAPIKeyRequired(); }### Answer:
@Test(expected = APIKeyNotAssignedException.class) public void should_Return_Exception_When_No_API_Key_Is_Supplied() throws APIKeyNotAssignedException { uriBuilder.build(); } |
### Question:
Utils { public static String readPropertyFrom(String propertyFilename, String propertyName) throws PropertyNotDefinedException { Properties prop = new Properties(); try { prop.load(new FileReader(new File(propertyFilename))); String propertyValue = prop.getProperty(propertyName); if(propertyValue != null) { return propertyValue; } throw new PropertyNotDefinedException("There is no property " + propertyName + " defined on file " + propertyFilename); } catch (IOException exception) { try { logger.info("Current path: " + new File(".").getCanonicalPath()); } catch (IOException e) { logger.info("Could not determine the current path"); } logger.error(exception.getMessage()); throw new IllegalStateException("IO Exception occurred due to the following: " + exception.getMessage()); } } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }### Answer:
@Test public void should_Return_Property_Value() throws PropertyNotDefinedException { String propertyValue = readPropertyFrom("src/test/resources/test.properties", "propertyKey"); assertThat("The property value is not the expected one", propertyValue, is("propertyValue")); }
@Test(expected = IllegalStateException.class) public void should_Fail_If_File_Does_Not_Exist() throws PropertyNotDefinedException { readPropertyFrom("non-existing-path", "propertyKey"); }
@Test(expected = PropertyNotDefinedException.class) public void should_Fail_If_Property_Does_Not_Exist() throws PropertyNotDefinedException { readPropertyFrom("src/test/resources/test.properties", "nonExistingPropertyKey"); } |
### Question:
Utils { public static boolean isAValidJSONText(String resultAsString) { try { new JSONObject(resultAsString); return true; } catch (JSONException ex) { return false; } } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }### Answer:
@Test public void should_Verify_Invalid_JSON_Text() { assertThat(isAValidJSONText("{abcde"), is(false)); }
@Test public void should_Verify_Valid_JSON_Text() { assertThat(isAValidJSONText("{color:'green', status: 'good'}"), is(true)); } |
### Question:
Utils { public static String urlEncode(String token) { if (token == null) { throw new IllegalArgumentException(THE_TOKEN_CANNOT_BE_NULL_MSG); } String encodedToken = token; try { encodedToken = URLEncoder.encode(token, UTF_8); } catch (UnsupportedEncodingException uee) { logger.warn(INVALID_TOKEN_WARNING); } return encodedToken; } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }### Answer:
@Test public void should_Return_A_Plus_When_Space_Is_Passed_To_Encode_Token() { assertThat(urlEncode(" "), is("+")); }
@Test(expected = IllegalArgumentException.class) public void should_Return_IllegalArgumentException_If_Null_Is_Passed_To_Encode_Token() { Utils.urlEncode(null); } |
### Question:
Utils { public static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator) { return StringUtils.substringBeforeLast(urlParameterTokens, paramSeparator); } private Utils(); static String dropTrailingSeparator(String urlParameterTokens, String paramSeparator); static String urlEncode(String token); static boolean isAValidJSONText(String resultAsString); static String readPropertyFrom(String propertyFilename, String propertyName); static String dropStartAndEndDelimiters(String inputString); static final String OPENING_BOX_BRACKET; static final String CLOSING_BOX_BRACKET; }### Answer:
@Test public void should_Remove_Trailing_Separator_From_String_When_A_Single_Separator_Is_Passed_In() { assertThat(dropTrailingSeparator("http: } |
### Question:
TracingChannelInterceptor extends ChannelInterceptorAdapter implements
ExecutorChannelInterceptor { @Override public void afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, Exception arg3) { if ((handler instanceof WebSocketAnnotationMethodMessageHandler || handler instanceof SubProtocolWebSocketHandler) && SimpMessageType.MESSAGE.equals(message.getHeaders().get(SIMP_MESSAGE_TYPE))) { message.getHeaders().get(OPENTRACING_SCOPE, Scope.class).close(); message.getHeaders().get(OPENTRACING_SPAN, Span.class).finish(); } } TracingChannelInterceptor(Tracer tracer, String spanKind); @Override Message<?> preSend(Message<?> message, MessageChannel channel); @Override void afterMessageHandled(Message<?> message, MessageChannel channel,
MessageHandler handler, Exception arg3); @Override Message<?> beforeHandle(Message<?> message, MessageChannel channel,
MessageHandler handler); }### Answer:
@Test public void testAfterMessageHandled() { Span span = mock(Span.class); Scope scope = mock(Scope.class); MessageHandler messageHandler = mock(WebSocketAnnotationMethodMessageHandler.class); MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi") .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE) .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION) .setHeader(TracingChannelInterceptor.OPENTRACING_SCOPE, scope) .setHeader(TracingChannelInterceptor.OPENTRACING_SPAN, span); TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer, Tags.SPAN_KIND_CLIENT); interceptor.afterMessageHandled(messageBuilder.build(), null, messageHandler, null); verify(span).finish(); verify(scope).close(); } |
### Question:
CustomAsyncConfigurerAutoConfiguration implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AsyncConfigurer && !(bean instanceof TracedAsyncConfigurer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; Tracer tracer = this.beanFactory.getBean(Tracer.class); return new TracedAsyncConfigurer(tracer, configurer); } return bean; } @Override Object postProcessBeforeInitialization(Object bean, String beanName); @Override Object postProcessAfterInitialization(Object bean, String beanName); @Override int getOrder(); @Override void setBeanFactory(BeanFactory beanFactory); }### Answer:
@Test public void should_return_bean_when_its_not_async_configurer() { CustomAsyncConfigurerAutoConfiguration configuration = new CustomAsyncConfigurerAutoConfiguration(); Object bean = configuration.postProcessAfterInitialization(new Object(), "someBean"); then(bean).isNotInstanceOf(TracedAsyncConfigurer.class); } |
### Question:
TracingMongoClientPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MongoClient && !(bean instanceof TracingMongoClient)) { final MongoClient client = (MongoClient) bean; final TracingCommandListener commandListener = new TracingCommandListener.Builder(tracer) .build(); return new TracingMongoClient(commandListener, client.getServerAddressList(), client.getCredentialsList(), client.getMongoClientOptions()); } return bean; } TracingMongoClientPostProcessor(Tracer tracer); @Override Object postProcessAfterInitialization(Object bean, String beanName); }### Answer:
@Test public void testNonMongoClientBeansAreReturnedUnaltered() { final Object expected = new Object(); final Object actual = processor.postProcessAfterInitialization(expected, "any-bean-name"); assertThat(actual).isSameAs(expected); }
@Test public void testMongoClientBeansReplacedWithTracingClient() { final MongoClient client = new MongoClient(new MongoClientURI("mongodb: final Object actual = processor.postProcessAfterInitialization(client, "any-bean-name"); assertThat(actual).isInstanceOf(TracingMongoClient.class); }
@Test public void testTracingMongoClientBeanNotWrapped() { final Object actual = processor.postProcessAfterInitialization(tracingClient, "any-bean-name"); assertThat(actual).isSameAs(tracingClient); } |
### Question:
LargeMessageProxy extends AbstractLoggingActor { public static Props props() { return Props.create(LargeMessageProxy.class); } static Props props(); @Override Receive createReceive(); static final String DEFAULT_NAME; }### Answer:
@Test public void testSmallMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(1), () -> { String shortMessage = "Hello, this is a short message!"; LargeMessageProxy.LargeMessage<String> shortStringMessage = new LargeMessageProxy.LargeMessage<String>(shortMessage, receiver); sender.tell(shortStringMessage, this.getRef()); this.expectMsg(shortMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; }
@Test public void testLargeMessageSending() { new TestKit(system) { { ActorRef sender = system.actorOf(TestActor.props(this.getRef()), "sender"); ActorRef receiver = system.actorOf(TestActor.props(this.getRef()), "receiver"); within(Duration.ofSeconds(2), () -> { StringBuffer longMessageBuffer = new StringBuffer("Hello, this is a String message with a very large payload!"); for (int i = 0; i < 1000; i++) longMessageBuffer.append("<content>"); String longMessage = longMessageBuffer.toString(); LargeMessageProxy.LargeMessage<String> longStringMessage = new LargeMessageProxy.LargeMessage<String>(longMessage, receiver); sender.tell(longStringMessage, this.getRef()); this.expectMsg(longMessage); assertTrue(this.getLastSender().equals(receiver)); expectNoMessage(); return null; }); } }; } |
### Question:
Worker extends AbstractLoggingActor { public static Props props() { return Props.create(Worker.class); } static Props props(); @Override void preStart(); @Override void postStop(); @Override Receive createReceive(); }### Answer:
@Test public void shouldFindCorrectPrimes() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(0, 1, 10), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(0, Arrays.asList(2L, 3L, 5L, 7L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; }
@Test public void shouldInterpretRangeCorrectly() { new TestKit(this.actorSystem) {{ ActorRef worker = actorSystem.actorOf(Worker.props()); worker.tell(new Worker.ValidationMessage(1, 5, 11), this.getRef()); Master.PrimesMessage expectedMsg = new Master.PrimesMessage(1, Arrays.asList(5L, 7L, 11L), true); this.expectMsg(Duration.create(3, "secs"), expectedMsg); }}; } |
### Question:
UserRepository { public LiveData<User> getUser(String email) { MutableLiveData<User> liveData = new MutableLiveData<>(); userDao.loadUser(email) .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUser(email) .compose(transformers.applySchedulersToFlowable()) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }### Answer:
@Test public void getUser() { User userEntity = new User("[email protected]", "John", "Doe"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUser(anyString())).thenReturn(Flowable.just(userEntity)); when(userApi.getUser(anyString())).thenReturn(Flowable.just(userModel)); Observer<User> observer = mock(Observer.class); userRepository.getUser(anyString()) .observeForever(observer); verify(userDao, times(1)).loadUser(anyString()); verify(userApi, times(1)).getUser(anyString()); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(userEntity); } |
### Question:
UserRepository { public LiveData<List<User>> getUsers() { MutableLiveData<List<User>> liveData = new MutableLiveData<>(); userDao.loadUsers() .compose(transformers.applySchedulersToFlowable()) .subscribe(liveData::setValue, Timber::d); userApi.getUsers() .compose(transformers.applySchedulersToFlowable()) .flatMapIterable(users -> users) .map(mapper::toEntity) .subscribe(userDao::saveUser, Timber::d); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }### Answer:
@Test public void getUsers() { User userEntityOne = new User("[email protected]", "John", "Doe"); User userEntityTwo = new User("[email protected]", "Jane", "Doe"); List<User> userEntities = new ArrayList<>(); List<com.jonathanpetitfrere.mvvm.repository.api.model.User> userModels = new ArrayList<>(); userEntities.add(userEntityOne); userEntities.add(userEntityTwo); userModels.add(mapper.toModel(userEntityOne)); userModels.add(mapper.toModel(userEntityTwo)); when(transformers.applySchedulersToFlowable()).thenReturn(flowable -> flowable); when(userDao.loadUsers()).thenReturn(Flowable.just(userEntities)); when(userApi.getUsers()).thenReturn(Flowable.just(userModels)); Observer<List<User>> observer = mock(Observer.class); userRepository.getUsers() .observeForever(observer); verify(userDao, times(userEntities.size())).saveUser(any()); verify(userApi, times(1)).getUsers(); verify(observer, only()).onChanged(userEntities); } |
### Question:
UserRepository { public LiveData<Boolean> saveUser(User user) { MutableLiveData<Boolean> liveData = new MutableLiveData<>(); Completable.fromAction(() -> userDao.saveUser(user)) .compose(transformers.applySchedulersToCompletable()) .subscribe(() -> liveData.setValue(true), throwable -> { Timber.d(throwable); liveData.setValue(false); }); return liveData; } @Inject UserRepository(); LiveData<User> getUser(String email); LiveData<List<User>> getUsers(); LiveData<Boolean> saveUser(User user); }### Answer:
@Test public void saveUserSuccess() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(true); }
@Test public void saveUserFail() { User userEntity = new User("[email protected]", "John", "Doe"); when(transformers.applySchedulersToCompletable()).thenReturn(completable -> completable); doThrow(Exception.class).when(userDao).saveUser(any()); Observer<Boolean> observer = mock(Observer.class); userRepository.saveUser(userEntity) .observeForever(observer); verify(userDao, times(1)).saveUser(userEntity); verify(observer, only()).onChanged(false); } |
### Question:
UserMapper { public User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity) { return new User(userEntity.getEmail(), userEntity.getFirstName(), userEntity.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }### Answer:
@Test public void toModel() { User userEntity = new User("[email protected]", "First Name", "Last Name"); com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = mapper.toModel(userEntity); assertEquals(userEntity.getEmail(), userModel.getEmail()); assertEquals(userEntity.getFirstName(), userModel.getFirstName()); assertEquals(userEntity.getLastName(), userModel.getLastName()); } |
### Question:
UserMapper { public com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel) { return new com.jonathanpetitfrere.mvvm.repository.persistence.entity.User(userModel.getEmail(), userModel.getFirstName(), userModel.getLastName()); } @Inject UserMapper(); User toModel(com.jonathanpetitfrere.mvvm.repository.persistence.entity.User userEntity); com.jonathanpetitfrere.mvvm.repository.persistence.entity.User toEntity(User userModel); }### Answer:
@Test public void toEntity() { com.jonathanpetitfrere.mvvm.repository.api.model.User userModel = new com.jonathanpetitfrere.mvvm.repository.api.model.User("[email protected]", "First Name", "Last Name"); User userEntity = mapper.toEntity(userModel); assertEquals(userModel.getEmail(), userEntity.getEmail()); assertEquals(userModel.getFirstName(), userEntity.getFirstName()); assertEquals(userModel.getLastName(), userEntity.getLastName()); } |
### Question:
RxIdler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private RxIdler(); @CheckResult @NonNull static RxJavaSchedulersHook hooks(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }### Answer:
@Test public void nullWrapArgumentsFails() { try { RxIdler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { RxIdler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
DelegatingIdlingResourceScheduler extends IdlingResourceScheduler { @Override public String getName() { return name; } DelegatingIdlingResourceScheduler(Scheduler delegate, String name); @Override String getName(); @Override boolean isIdleNow(); @Override void registerIdleTransitionCallback(ResourceCallback callback); @Override Worker createWorker(); }### Answer:
@Test public void name() { assertEquals("Bob", scheduler.getName()); } |
### Question:
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return new Function<Callable<Scheduler>, Scheduler>() { @Override public Scheduler apply(Callable<Scheduler> delegate) throws Exception { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.call(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; } }; } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }### Answer:
@Test public void createNullArgumentsFlow() { try { Rx2Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
Rx2Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx2Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Callable<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }### Answer:
@Test public void nullWrapArgumentsFails() { try { Rx2Idler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { Rx2Idler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name) { if (name == null) throw new NullPointerException("name == null"); return delegate -> { IdlingResourceScheduler scheduler = new DelegatingIdlingResourceScheduler(delegate.get(), name); IdlingRegistry.getInstance().register(scheduler); return scheduler; }; } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }### Answer:
@Test public void createNullArgumentsFlow() { try { Rx3Idler.create(null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
Rx3Idler { @SuppressWarnings("ConstantConditions") @CheckResult @NonNull public static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name) { if (scheduler == null) throw new NullPointerException("scheduler == null"); if (name == null) throw new NullPointerException("name == null"); return new DelegatingIdlingResourceScheduler(scheduler, name); } private Rx3Idler(); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static Function<Supplier<Scheduler>, Scheduler> create(@NonNull final String name); @SuppressWarnings("ConstantConditions") // Public API guarding. @CheckResult @NonNull static IdlingResourceScheduler wrap(@NonNull Scheduler scheduler, @NonNull String name); }### Answer:
@Test public void nullWrapArgumentsFails() { try { Rx3Idler.wrap(null, "Bob"); fail(); } catch (NullPointerException e) { assertEquals("scheduler == null", e.getMessage()); } try { Rx3Idler.wrap(new TestScheduler(), null); fail(); } catch (NullPointerException e) { assertEquals("name == null", e.getMessage()); } } |
### Question:
SupportUtils { public static String normalize(@NonNull String input) { String trimmedInput = input.trim(); Uri uri = Uri.parse(trimmedInput); for (final String s : SupportUtils.SUPPORTED_URLS) { if (s.equals(input)) { return input; } } if (TextUtils.isEmpty(uri.getScheme())) { uri = Uri.parse("http: } return uri.toString(); } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void testNormalize() { assertEquals("http: assertEquals("https: assertEquals("https: assertEquals("file: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: for (final String supported : SupportUtils.SUPPORTED_URLS) { assertEquals(supported, SupportUtils.normalize(supported)); } } |
### Question:
SupportUtils { public static String getSumoURLForTopic(final Context context, final String topic) { String escapedTopic; try { escapedTopic = URLEncoder.encode(topic, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("utf-8 should always be available", e); } final String appVersion; try { appVersion = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Focus", e); } final String osTarget = "Android"; final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void getSumoURLForTopic() throws Exception { final String appVersion; try { appVersion = ApplicationProvider.getApplicationContext().getPackageManager().getPackageInfo(ApplicationProvider.getApplicationContext().getPackageName(), 0).versionName; } catch (PackageManager.NameNotFoundException e) { throw new IllegalStateException("Unable find package details for Rocket", e); } Locale.setDefault(Locale.GERMANY); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); Locale.setDefault(Locale.CANADA_FRENCH); assertEquals("https: SupportUtils.getSumoURLForTopic(ApplicationProvider.getApplicationContext(), "foobar")); } |
### Question:
SupportUtils { public static String getManifestoURL() { final String langTag = Locales.getLanguageTag(Locale.getDefault()); return "https: } static String normalize(@NonNull String input); static boolean isUrl(@Nullable String url); static boolean isTemplateSupportPages(String url); static String getSumoURLForTopic(final Context context, final String topic); static String getManifestoURL(); static String getPrivacyURL(); static String getYourRightsURI(); static String getAboutURI(); static void loadSupportPages(WebView webview, String url); static final String BLANK_URL; static final String FOCUS_ABOUT_URL; static final String YOUR_RIGHTS_URI; static final String PRIVACY_URL; static final String ABOUT_URI; }### Answer:
@Test public void getManifestoURL() throws Exception { Locale.setDefault(Locale.UK); assertEquals("https: SupportUtils.getManifestoURL()); Locale.setDefault(Locale.KOREA); assertEquals("https: SupportUtils.getManifestoURL()); } |
### Question:
ColorUtils { public static int getReadableTextColor(final int backgroundColor) { final int greyValue = grayscaleFromRGB(backgroundColor); if (greyValue < 186) { return Color.WHITE; } else { return Color.BLACK; } } static int getReadableTextColor(final int backgroundColor); }### Answer:
@Test public void testGetReadableTextColor() { assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(Color.WHITE)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(Color.BLACK)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff6f4ec)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xffdb4437)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xff527da3)); assertEquals(Color.BLACK, ColorUtils.getReadableTextColor(0xfff2f7fc)); assertEquals(Color.WHITE, ColorUtils.getReadableTextColor(0xfff57c00)); } |
### Question:
MimeUtils { public static boolean isText(@Nullable String type) { return !TextUtils.isEmpty(type) && textPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testText() { assertTrue(MimeUtils.isText("text")); assertFalse(MimeUtils.isText("text/plain/")); assertFalse(MimeUtils.isText("text/plain*")); } |
### Question:
MimeUtils { public static boolean isImage(@Nullable String type) { return !TextUtils.isEmpty(type) && imgPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testImage() { assertTrue(MimeUtils.isImage("image")); assertFalse(MimeUtils.isImage("image/png/")); assertFalse(MimeUtils.isImage("image/png*")); } |
### Question:
MimeUtils { public static boolean isAudio(@Nullable String type) { return !TextUtils.isEmpty(type) && audioPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testAudio() { assertTrue(MimeUtils.isAudio("audio")); assertFalse(MimeUtils.isAudio("audio/mp3/")); assertFalse(MimeUtils.isAudio("audio/mp3*")); } |
### Question:
MimeUtils { public static boolean isVideo(@Nullable String type) { return !TextUtils.isEmpty(type) && videoPattern.matcher(type).find(); } private MimeUtils(); static boolean isText(@Nullable String type); static boolean isImage(@Nullable String type); static boolean isAudio(@Nullable String type); static boolean isVideo(@Nullable String type); }### Answer:
@Test public void testVideo() { assertTrue(MimeUtils.isVideo("video")); assertFalse(MimeUtils.isVideo("video/mp4/")); assertFalse(MimeUtils.isVideo("video/mp4*")); } |
### Question:
UrlUtils { public static boolean isPermittedResourceProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return scheme.startsWith("http") || scheme.startsWith("https") || scheme.startsWith("file") || scheme.startsWith("data"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isPermittedResourceProtocol() { assertTrue(UrlUtils.isPermittedResourceProtocol("http")); assertTrue(UrlUtils.isPermittedResourceProtocol("https")); assertTrue(UrlUtils.isPermittedResourceProtocol("data")); assertTrue(UrlUtils.isPermittedResourceProtocol("file")); assertFalse(UrlUtils.isPermittedResourceProtocol("nielsenwebid")); } |
### Question:
TabEntity { public boolean isValid() { final boolean hasId = !TextUtils.isEmpty(this.getId()); final boolean hasUrl = !TextUtils.isEmpty(this.getUrl()); return hasId && hasUrl; } @Ignore TabEntity(String id, String parentId); TabEntity(String id, String parentId, String title, String url); @NonNull String getId(); void setId(@NonNull String id); String getParentId(); void setParentId(String parentId); String getTitle(); void setTitle(String title); String getUrl(); void setUrl(String url); boolean isValid(); @Override String toString(); }### Answer:
@Test public void testSanity() { Assert.assertFalse(new TabEntity(null, null).isValid()); Assert.assertFalse(new TabEntity(null, null, "title", "").isValid()); Assert.assertFalse(new TabEntity(null, null, null, "url").isValid()); Assert.assertFalse(new TabEntity("id", null, null, null).isValid()); Assert.assertTrue(new TabEntity("id", null, null, "url").isValid()); Assert.assertTrue(new TabEntity("id", null, "title", "url").isValid()); } |
### Question:
BrowsingSession { public static synchronized BrowsingSession getInstance() { if (instance == null) { instance = new BrowsingSession(); } return instance; } private BrowsingSession(); static synchronized BrowsingSession getInstance(); void countBlockedTracker(); void setBlockedTrackerCount(int count); void resetTrackerCount(); LiveData<Integer> getBlockedTrackerCount(); }### Answer:
@Test public void testSingleton() { assertNotNull(BrowsingSession.getInstance()); assertEquals(BrowsingSession.getInstance(), BrowsingSession.getInstance()); } |
### Question:
SearchEngineParser { public static SearchEngine load(AssetManager assetManager, String identifier, String path) throws IOException { try (final InputStream stream = assetManager.open(path)) { return load(identifier, stream); } catch (XmlPullParserException e) { throw new AssertionError("Parser exception while reading " + path, e); } } static SearchEngine load(AssetManager assetManager, String identifier, String path); }### Answer:
@Test public void testParser() throws Exception { final InputStream stream = new FileInputStream(searchPluginPath); final SearchEngine searchEngine = SearchEngineParser.load(searchEngineIdentifier, stream); assertEquals(searchEngineIdentifier, searchEngine.getIdentifier()); assertNotNull(searchEngine.getName()); assertFalse(TextUtils.isEmpty(searchEngine.getName())); assertNotNull(searchEngine.getIcon()); final String searchTerm = UUID.randomUUID().toString(); final String searchUrl = searchEngine.buildSearchUrl(searchTerm); assertNotNull(searchUrl); assertFalse(TextUtils.isEmpty(searchUrl)); assertTrue(searchUrl.contains(searchTerm)); stream.close(); } |
### Question:
Trie { public Trie findNode(final FocusString string) { if (terminator) { if (string.length() == 0 || string.charAt(0) == '.') { return this; } } else if (string.length() == 0) { return null; } final Trie next = children.get(string.charAt(0)); if (next == null) { return null; } return next.findNode(string.substring(1)); } private Trie(char character, Trie parent); Trie findNode(final FocusString string); Trie put(final FocusString string); Trie put(char character); static Trie createRootNode(); final SparseArray<Trie> children; public boolean terminator; }### Answer:
@Test public void findNode() throws Exception { final Trie trie = Trie.createRootNode(); assertNull(trie.findNode(FocusString.create("hello"))); final Trie putNode = trie.put(FocusString.create("hello")); final Trie foundNode = trie.findNode(FocusString.create("hello")); assertNotNull(putNode); assertNotNull(foundNode); assertEquals(putNode, foundNode); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("hellohello")); assertNotNull(trie.findNode(FocusString.create("hello"))); assertNotNull(trie.findNode(FocusString.create("hellohello"))); assertNull(trie.findNode(FocusString.create("hell"))); assertNull(trie.findNode(FocusString.create("hellop"))); trie.put(FocusString.create("foo.com").reverse()); assertNotNull(trie.findNode(FocusString.create("foo.com").reverse())); assertNotNull(trie.findNode(FocusString.create("bar.foo.com").reverse())); assertNull(trie.findNode(FocusString.create("bar-foo.com").reverse())); assertNull(trie.findNode(FocusString.create("oo.com").reverse())); } |
### Question:
TrackingProtectionWebViewClient extends WebViewClient { @Override public WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request) { if (!blockingEnabled) { return super.shouldInterceptRequest(view, request); } final Uri resourceUri = request.getUrl(); final String scheme = resourceUri.getScheme(); if (!request.isForMainFrame() && !scheme.equals("http") && !scheme.equals("https") && !scheme.equals("blob")) { return new WebResourceResponse(null, null, null); } final UrlMatcher matcher = getMatcher(view.getContext()); if ((currentPageURL != null && !request.isForMainFrame()) && matcher.matches(resourceUri, Uri.parse(currentPageURL))) { BrowsingSession.getInstance().countBlockedTracker(); return new WebResourceResponse(null, null, null); } return super.shouldInterceptRequest(view, request); } TrackingProtectionWebViewClient(final Context context); static void triggerPreload(final Context context); void setBlockingEnabled(boolean enabled); boolean isBlockingEnabled(); @Override WebResourceResponse shouldInterceptRequest(final WebView view, final WebResourceRequest request); void notifyCurrentURL(final String url); @Override void onPageStarted(WebView view, String url, Bitmap favicon); @Override void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm); }### Answer:
@Test public void shouldInterceptRequest() throws Exception { trackingProtectionWebViewClient.notifyCurrentURL("http: { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceAllowed(response); } { final WebResourceRequest request = createRequest("http: final WebResourceResponse response = trackingProtectionWebViewClient.shouldInterceptRequest(webView, request); assertResourceBlocked(response); } } |
### Question:
DiskLruCache implements Closeable { public synchronized void close() throws IOException { if (journalWriter == null) { return; } for (Entry entry : new ArrayList<Entry>(lruEntries.values())) { if (entry.currentEditor != null) { entry.currentEditor.abort(); } } trimToSize(); journalWriter.close(); journalWriter = null; } private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize); static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize); synchronized Value get(String key); Editor edit(String key); File getDirectory(); synchronized long getMaxSize(); synchronized void setMaxSize(long maxSize); synchronized long size(); synchronized boolean remove(String key); synchronized boolean isClosed(); synchronized void flush(); synchronized void close(); void delete(); }### Answer:
@Test public void emptyCache() throws Exception { cache.close(); assertJournalEquals(); } |
### Question:
UrlUtils { public static boolean isSupportedProtocol(@NonNull final String scheme) { if (TextUtils.isEmpty(scheme)) { return false; } return isPermittedResourceProtocol(scheme) || scheme.startsWith("error"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isPermittedProtocol() { assertTrue(UrlUtils.isSupportedProtocol("http")); assertTrue(UrlUtils.isSupportedProtocol("https")); assertTrue(UrlUtils.isSupportedProtocol("error")); assertTrue(UrlUtils.isSupportedProtocol("data")); assertFalse(UrlUtils.isSupportedProtocol("market")); } |
### Question:
UrlUtils { public static boolean isSearchQuery(String text) { return text.contains(" "); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void testIsSearchQuery() { assertTrue(UrlUtils.isSearchQuery("hello world")); assertFalse(UrlUtils.isSearchQuery("mozilla.org")); assertFalse(UrlUtils.isSearchQuery("mozilla")); } |
### Question:
UrlUtils { public static String stripUserInfo(@Nullable String url) { if (TextUtils.isEmpty(url)) { return ""; } try { URI uri = new URI(url); final String userInfo = uri.getUserInfo(); if (userInfo == null) { return url; } uri = new URI(uri.getScheme(), null, uri.getHost(), uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment()); return uri.toString(); } catch (URISyntaxException e) { return url; } } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test @SuppressLint("AuthLeak") public void testStripUserInfo() { assertEquals("", UrlUtils.stripUserInfo(null)); assertEquals("", UrlUtils.stripUserInfo("")); assertEquals("https: assertEquals("https: assertEquals("[email protected]", UrlUtils.stripUserInfo("[email protected]")); assertEquals("ftp: assertEquals("öäü102ß", UrlUtils.stripUserInfo("öäü102ß")); } |
### Question:
UrlUtils { public static boolean isInternalErrorURL(final String url) { return "data:text/html;charset=utf-8;base64,".equals(url); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isInternalErrorURL() { assertTrue(UrlUtils.isInternalErrorURL("data:text/html;charset=utf-8;base64,")); assertFalse(UrlUtils.isInternalErrorURL("http: assertFalse(UrlUtils.isInternalErrorURL("https: assertFalse(UrlUtils.isInternalErrorURL("www.mozilla.org")); assertFalse(UrlUtils.isInternalErrorURL("error:-8")); assertFalse(UrlUtils.isInternalErrorURL("hello world")); } |
### Question:
UrlUtils { public static boolean isHttpOrHttps(String url) { if (TextUtils.isEmpty(url)) { return false; } return url.startsWith("http:") || url.startsWith("https:"); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void isHttpOrHttpsUrl() { assertFalse(UrlUtils.isHttpOrHttps(null)); assertFalse(UrlUtils.isHttpOrHttps("")); assertFalse(UrlUtils.isHttpOrHttps(" ")); assertFalse(UrlUtils.isHttpOrHttps("mozilla.org")); assertFalse(UrlUtils.isHttpOrHttps("httpstrf: assertTrue(UrlUtils.isHttpOrHttps("https: assertTrue(UrlUtils.isHttpOrHttps("http: assertTrue(UrlUtils.isHttpOrHttps("http: } |
### Question:
UrlUtils { public static String stripCommonSubdomains(@Nullable String host) { return stripPrefix(host, COMMON_SUBDOMAINS_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void stripCommonSubdomains() { assertEquals(UrlUtils.stripCommonSubdomains("m.mobile.com"), "mobile.com"); assertEquals(UrlUtils.stripCommonSubdomains("mobile.mozilla.org"), "mozilla.org"); assertEquals(UrlUtils.stripCommonSubdomains("www.synology.com"), "synology.com"); assertEquals(UrlUtils.stripCommonSubdomains("i.j.k"), "i.j.k"); } |
### Question:
UrlUtils { public static String stripHttp(@Nullable String host) { return stripPrefix(host, HTTP_SCHEME_PREFIX_ARRAY); } static boolean isHttpOrHttps(String url); static boolean isSearchQuery(String text); static String stripUserInfo(@Nullable String url); static boolean isPermittedResourceProtocol(@NonNull final String scheme); static boolean isSupportedProtocol(@NonNull final String scheme); static boolean isInternalErrorURL(final String url); static boolean urlsMatchExceptForTrailingSlash(final @NonNull String url1, final @NonNull String url2); static String stripCommonSubdomains(@Nullable String host); static String stripHttp(@Nullable String host); static String stripPrefix(@Nullable String host, @NonNull String[] prefixArray); }### Answer:
@Test public void stripHttp() { assertEquals(UrlUtils.stripHttp("http: assertEquals(UrlUtils.stripHttp("https: assertEquals(UrlUtils.stripHttp("ftp: assertEquals(UrlUtils.stripHttp("synology.com"), "synology.com"); } |
### Question:
TabUtil { public static Bundle argument(@Nullable final String parentId, boolean fromExternal, boolean toFocus) { final Bundle bundle = new Bundle(); if (!TextUtils.isEmpty(parentId)) { bundle.putString(ARG_PARENT_ID, parentId); } bundle.putBoolean(ARG_EXTERNAL, fromExternal); bundle.putBoolean(ARG_FOCUS, toFocus); return bundle; } private TabUtil(); static Bundle argument(@Nullable final String parentId,
boolean fromExternal,
boolean toFocus); @Nullable static String getParentId(@NonNull final Bundle bundle); static boolean isFromExternal(@NonNull final Bundle bundle); static boolean toFocus(@NonNull final Bundle bundle); }### Answer:
@Test public void testCreation() { Assert.assertNotNull(TabUtil.argument("parent_id", false, false)); Assert.assertNotNull(TabUtil.argument(null, false, false)); Assert.assertNotNull(TabUtil.argument(null, false, true)); Assert.assertNotNull(TabUtil.argument(null, true, false)); } |
### Question:
PathUtil { public static Path getWindupUserDir() { String userHome = System.getProperty("user.home"); if (userHome == null) { Path path = new File("").toPath(); LOG.warning("$USER_HOME not set, using [" + path.toAbsolutePath().toString() + "] instead."); return path; } return Paths.get(userHome).resolve(".mta"); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }### Answer:
@Test public void testWindupUserDir() { Assert.assertEquals(Paths.get(""), PathUtil.getWindupUserDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta"), PathUtil.getWindupUserDir()); } |
### Question:
PathUtil { public static Path getUserIgnoreDir() { return getUserSubdirectory(IGNORE_DIRECTORY_NAME); } static Path getWindupUserDir(); static Path getWindupHome(); static void setWindupHome(Path windupHome); static Path getUserCacheDir(); static Path getWindupCacheDir(); static Path getUserIgnoreDir(); static Path getWindupIgnoreDir(); static Path getWindupAddonsDir(); static Path getUserRulesDir(); static Path getUserLabelsDir(); static Path getWindupRulesDir(); static Path getWindupLabelsDir(); static String cleanFileName(String badFileName); static String classFilePathToClassname(String relativePath); static Path getRootFolderForSource(Path sourceFilePath, String packageName); static boolean isInSubDirectory(File dir, File file); static String pathToPackageName(String relativePath); static void createDirectory(Path dir, String dirDesc); static final String WINDUP_HOME; static final String WINDUP_RULESETS_DIR_SYSPROP; static final String WINDUP_LABELSETS_DIR_SYSPROP; static final String RULES_DIRECTORY_NAME; static final String LABELS_DIRECTORY_NAME; static final String IGNORE_DIRECTORY_NAME; static final String CACHE_DIRECTORY_NAME; static final String ADDONS_DIRECTORY_NAME; static String LIBRARY_DIRECTORY_NAME; static String BINARY_DIRECTORY_NAME; }### Answer:
@Test public void testWindupIgnoreDir() { Assert.assertEquals(Paths.get("ignore"), PathUtil.getUserIgnoreDir()); setUserHome("/foo"); Assert.assertEquals(Paths.get("/foo", ".mta", "ignore"), PathUtil.getUserIgnoreDir()); } |
### Question:
TickCounter { public TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration) { this(tickHandler, maxTicks, tickDuration, 0); } TickCounter(TickHandler tickHandler, int maxTicks,
int tickDuration); TickCounter(TickHandler tickHandler, int maxTicks, int tickDuration,
int tickOffset); boolean update(); void reset(); int getTickCount(); boolean isRightTick(int tickInterval); }### Answer:
@Test public void testTickCounter() { int maxTicks = 75; int tickDuration = 30; int deltaMultiplier = 5; t = new TickCounter(new TickHandler() { @Override public void onTick() { tickCount++; } @Override public int getDeltaMultiplier() { return deltaMultiplier; } }, maxTicks, tickDuration); long startTime = System.currentTimeMillis(); while (!t.update()) { } long duration = System.currentTimeMillis() - startTime; assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); assertEquals(maxTicks * tickDuration / deltaMultiplier, duration); assertEquals(false, t.update()); assertEquals(tickCount, t.getTickCount()); assertEquals(maxTicks, t.getTickCount()); t.reset(); tickCount = 0; while (!t.update()) { } assertEquals(tickCount, t.getTickCount()); } |
### Question:
CollectionUtils { public static synchronized <T, E> T getKeyByValue(Map<T, E> map, E value) { Preconditions.checkNotNull(map, "The map cannot be null"); for (Entry<T, E> entry : map.entrySet()) { if (Objects.equals(value, entry.getValue())) { return entry.getKey(); } } return null; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testKeyByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 1); map.put(2, 4); map.put(3, 9); map.put(4, 16); assertEquals((Integer) 1, CollectionUtils.getKeyByValue(map, 1)); assertEquals((Integer) 2, CollectionUtils.getKeyByValue(map, 4)); assertEquals((Integer) 3, CollectionUtils.getKeyByValue(map, 9)); assertEquals((Integer) 4, CollectionUtils.getKeyByValue(map, 16)); assertEquals(null, CollectionUtils.getKeyByValue(map, 5)); } |
### Question:
CollectionUtils { public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue( Map<K, V> map) { Preconditions.checkNotNull(map, "The map cannot be null"); List<Entry<K, V>> list = new ArrayList<>(map.entrySet()); list.sort(Entry.comparingByValue()); Map<K, V> result = new LinkedHashMap<>(); for (Entry<K, V> entry : list) { result.put(entry.getKey(), entry.getValue()); } return result; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testSortByValue() { Map<Integer, Integer> map = new HashMap<>(); map.put(1, 16); map.put(2, 8); map.put(3, 9); map.put(4, 5); map.put(5, 15); map = CollectionUtils.sortByValue(map); Integer[] tmp = map.keySet().toArray(new Integer[5]); assertEquals((Integer) 1, tmp[4]); assertEquals((Integer) 5, tmp[3]); assertEquals((Integer) 3, tmp[2]); assertEquals((Integer) 2, tmp[1]); assertEquals((Integer) 4, tmp[0]); } |
### Question:
CollectionUtils { public static <T extends Comparable<T>> T findMostPopularElement( List<T> list) { Preconditions.checkNotNull(list, "The list cannot be null"); Collections.sort(list); T previous = list.get(0); T popular = list.get(0); int count = 1; int maxCount = 1; for (int i = 1; i < list.size(); i++) { if (list.get(i) == previous) count++; else { if (count > maxCount) { popular = list.get(i - 1); maxCount = count; } previous = list.get(i); count = 1; } } return count > maxCount ? list.get(list.size() - 1) : popular; } private CollectionUtils(); static synchronized T getKeyByValue(Map<T, E> map, E value); static Map<K, V> sortByValue(
Map<K, V> map); static T findMostPopularElement(
List<T> list); }### Answer:
@Test public void testFindMostPopular() { Integer[] array = {1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7, 8}; List<Integer> list = new ArrayList<>(Arrays.asList(array)); assertEquals((Integer) 5, CollectionUtils.findMostPopularElement(list)); } |
### Question:
JwtUserFactory { public static JwtUser create(User user) { return new JwtUser( user.getId(), user.getUsername(), user.getFirstname(), user.getLastname(), user.getPassword(), user.getEmail(), user.getEnabled(), user.getLastPasswordResetDate().getTime(), mapUserRolesToGrantedAuthorities(user.getRoles()), user.getRoles() ); } private JwtUserFactory(); static JwtUser create(User user); }### Answer:
@Test public void whenCreateCalledWithUserModelThenExpectJwtUserDetailsToBeReturned() throws Exception { final User user = new User(); user.setId(USER_ID); user.setUsername(USERNAME); user.setPassword(PASSWORD); user.setFirstname(FIRSTNAME); user.setLastname(LASTNAME); user.setEmail(EMAIL); user.setEnabled(USER_ENABLED); user.setLastPasswordResetDate(LAST_PASSWORD_RESET_DATE); user.setRoles(createRoles(user)); final JwtUser userDetails = JwtUserFactory.create(user); assertEquals(userDetails.getId(), USER_ID); assertEquals(userDetails.getUsername(), USERNAME); assertEquals(userDetails.getPassword(), PASSWORD); assertEquals(userDetails.getFirstname(), FIRSTNAME); assertEquals(userDetails.getLastname(), LASTNAME); assertEquals(userDetails.getEmail(), EMAIL); assertEquals(userDetails.isEnabled(), USER_ENABLED); assertEquals(userDetails.getLastPasswordResetDate(), LAST_PASSWORD_RESET_DATE.getTime()); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_ADMIN.name())); assertTrue(userDetails.getRoles().contains(RoleName.ROLE_USER.name())); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_ADMIN.name()))); assertTrue(userDetails.getAuthorities().contains(new SimpleGrantedAuthority(RoleName.ROLE_USER.name()))); } |
### Question:
JwtAuthenticationEntryPoint implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException { response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } @Override void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException); }### Answer:
@Test public void whenCommenceCalledThenExpectUnauthorizedResponse() throws Exception { final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint = new JwtAuthenticationEntryPoint(); jwtAuthenticationEntryPoint.commence(request, response, authException); verify(response, times(1)).sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); } |
### Question:
JwtUserDetailsService implements UserDetailsService { @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { final User user = userRepository.findByUsername(username); if (user == null) { throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username)); } else { return JwtUserFactory.create(user); } } @Autowired JwtUserDetailsService(UserRepository userRepository); @Override UserDetails loadUserByUsername(String username); }### Answer:
@Test public void whenLoadByUsernameCalledWithKnownUsernameThenExpectUserDetailsToBeReturned() throws Exception { PowerMock.mockStatic(JwtUserFactory.class); final User user = PowerMock.createMock(User.class); final JwtUser jwtUser = EasyMock.createMock(JwtUser.class); expect(userRepository.findByUsername(KNOWN_USERNAME)).andStubReturn(user); expect(JwtUserFactory.create(eq(user))).andStubReturn(jwtUser); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); final JwtUser userDetails = (JwtUser) jwtUserDetailsService.loadUserByUsername(KNOWN_USERNAME); assertEquals(jwtUser, userDetails); PowerMock.verifyAll(); }
@Test(expected = UsernameNotFoundException.class) public void whenLoadByUsernameCalledWithUnknownUsernameThenExpectUsernameNotFoundException() throws Exception { expect(userRepository.findByUsername(UNKNOWN_USERNAME)).andStubReturn(null); PowerMock.replayAll(); final JwtUserDetailsService jwtUserDetailsService = new JwtUserDetailsService(userRepository); jwtUserDetailsService.loadUserByUsername(UNKNOWN_USERNAME); PowerMock.verifyAll(); } |
### Question:
JwtUtils { public String getUsernameFromTokenClaims(Claims claims) { try { final String username = claims.getSubject(); if (username == null) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg); } return username; } catch (Exception e) { final String errorMsg = "Failed to extract username claim from token!"; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testUsernameCanBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(USERNAME); assertThat(jwtUtils.getUsernameFromTokenClaims(claims)).isEqualTo(USERNAME); verify(claims, times(1)).getSubject(); }
@Test(expected = JwtAuthenticationException.class) public void testExceptionThrownIfUsernameCannotBeExtractedFromTokenClaims() throws Exception { when(claims.getSubject()).thenReturn(null); jwtUtils.getUsernameFromTokenClaims(claims); verify(claims, times(1)).getSubject(); } |
### Question:
OptionalConfig { public Map<String, String> getItems() { return items; } OptionalConfig(); Map<String, String> getItems(); void setItems(Map<String, String> items); @Override String toString(); }### Answer:
@Test public void testAddingAndFetchingOptionalConfigItems() throws Exception { final OptionalConfig strategyConfig = new OptionalConfig(); strategyConfig.getItems().put(BUY_FEE_CONFIG_ITEM_KEY, BUY_FEE_CONFIG_ITEM_VALUE); strategyConfig.getItems().put(SELL_FEE_CONFIG_ITEM_KEY, SELL_FEE_CONFIG_ITEM_VALUE); assertEquals(2, strategyConfig.getItems().size()); assertEquals(BUY_FEE_CONFIG_ITEM_VALUE, strategyConfig.getItems().get(BUY_FEE_CONFIG_ITEM_KEY)); assertEquals(SELL_FEE_CONFIG_ITEM_VALUE, strategyConfig.getItems().get(SELL_FEE_CONFIG_ITEM_KEY)); } |
### Question:
JwtUtils { Date getIssuedAtDateFromTokenClaims(Claims claims) throws JwtAuthenticationException { try { return claims.getIssuedAt(); } catch (Exception e) { final String errorMsg = "Failed to extract iat claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testIssuedAtDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.getIssuedAt()).thenReturn(ISSUED_AT_DATE); assertThat(jwtUtils.getIssuedAtDateFromTokenClaims(claims)) .isCloseTo(ISSUED_AT_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); verify(claims, times(1)).getIssuedAt(); } |
### Question:
JwtUtils { Date getExpirationDateFromTokenClaims(Claims claims) throws JwtAuthenticationException { try { return claims.getExpiration(); } catch (Exception e) { final String errorMsg = "Failed to extract expiration claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testExpirationDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.getExpiration()).thenReturn(EXPIRATION_DATE); assertThat(jwtUtils.getExpirationDateFromTokenClaims(claims)) .isCloseTo(EXPIRATION_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); verify(claims, times(1)).getExpiration(); } |
### Question:
JwtUtils { public List<GrantedAuthority> getRolesFromTokenClaims(Claims claims) throws JwtAuthenticationException { final List<GrantedAuthority> roles = new ArrayList<>(); try { @SuppressWarnings("unchecked") final List<String> rolesFromClaim = (List<String>) claims.get(CLAIM_KEY_ROLES); for (final String roleFromClaim : rolesFromClaim) { roles.add(new SimpleGrantedAuthority(roleFromClaim)); } return roles; } catch (Exception e) { final String errorMsg = "Failed to extract roles claim from token!"; LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testRolesCanBeExtractedFromTokenClaims() throws Exception { when(claims.get(JwtUtils.CLAIM_KEY_ROLES)).thenReturn(ROLES); final List<GrantedAuthority> roles = jwtUtils.getRolesFromTokenClaims(claims); assertThat(roles.size()).isEqualTo(2); assertThat(roles.get(0).getAuthority()).isEqualTo(RoleName.ROLE_ADMIN.name()); assertThat(roles.get(1).getAuthority()).isEqualTo(RoleName.ROLE_USER.name()); verify(claims, times(1)).get(JwtUtils.CLAIM_KEY_ROLES); } |
### Question:
JwtUtils { Date getLastPasswordResetDateFromTokenClaims(Claims claims) { Date lastPasswordResetDate; try { lastPasswordResetDate = new Date((Long) claims.get(CLAIM_KEY_LAST_PASSWORD_CHANGE_DATE)); } catch (Exception e) { LOG.error("Failed to extract lastPasswordResetDate claim from token!", e); lastPasswordResetDate = null; } return lastPasswordResetDate; } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void testLastPasswordResetDateCanBeExtractedFromTokenClaims() throws Exception { when(claims.get(JwtUtils.CLAIM_KEY_LAST_PASSWORD_CHANGE_DATE)) .thenReturn(LAST_PASSWORD_RESET_DATE.getTime()); assertThat(jwtUtils.getLastPasswordResetDateFromTokenClaims(claims)) .isCloseTo(LAST_PASSWORD_RESET_DATE, GRADLE_FRIENDLY_TIME_TOLERANCE_IN_MILLIS); } |
### Question:
JwtUtils { public Claims validateTokenAndGetClaims(String token) { try { final Claims claims = getClaimsFromToken(token); final Date created = getIssuedAtDateFromTokenClaims(claims); final Date lastPasswordResetDate = getLastPasswordResetDateFromTokenClaims(claims); if (isCreatedBeforeLastPasswordReset(created, lastPasswordResetDate)) { final String errorMsg = "Invalid token! Created date claim is before last password reset date." + " Created date: " + created + " Password reset date: " + lastPasswordResetDate; LOG.error(errorMsg); throw new JwtAuthenticationException(errorMsg); } return claims; } catch (Exception e) { final String errorMsg = "Invalid token! Details: " + e.getMessage(); LOG.error(errorMsg, e); throw new JwtAuthenticationException(errorMsg, e); } } Claims validateTokenAndGetClaims(String token); String generateToken(JwtUser userDetails); boolean canTokenBeRefreshed(Claims claims, Date lastPasswordReset); String refreshToken(String token); String getUsernameFromTokenClaims(Claims claims); List<GrantedAuthority> getRolesFromTokenClaims(Claims claims); }### Answer:
@Test public void whenValidateTokenCalledWithNonExpiredTokenThenExpectSuccess() throws Exception { final String token = createToken(); assertThat(jwtUtils.validateTokenAndGetClaims(token)).isNotNull(); }
@Test(expected = JwtAuthenticationException.class) public void whenValidateTokenCalledWithExpiredTokenThenExpectFailure() throws Exception { ReflectionTestUtils.setField(jwtUtils, "allowedClockSkewInSecs", 0L); ReflectionTestUtils.setField(jwtUtils, "expirationInSecs", 0L); final String token = createToken(); jwtUtils.validateTokenAndGetClaims(token); }
@Test(expected = JwtAuthenticationException.class) public void whenValidateTokenCalledWithCreatedDateEarlierThanLastPasswordResetDateThenExpectFailure() throws Exception { final String token = createTokenWithInvalidCreationDate(); jwtUtils.validateTokenAndGetClaims(token); } |
### Question:
Properlty { public Optional<BigDecimal> getBigDecimal(String key) { return get(key).map((val) -> new BigDecimal(val)); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnDefaultBigDecimal() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1, prop.getBigDecimal("key.one", new BigDecimal(10)).intValue()); assertEquals(10, prop.getBigDecimal("key.two", new BigDecimal(10)).intValue()); } |
### Question:
Properlty { public Optional<BigInteger> getBigInteger(String key) { return get(key).map((val) -> new BigInteger(val)); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnDefaultBigInteger() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "1"); final Properlty prop = buildProperlty(properties); assertEquals(1, prop.getBigInteger("key.one", new BigInteger("10")).intValue()); assertEquals(10, prop.getBigInteger("key.two", new BigInteger("10")).intValue()); } |
### Question:
Properlty { public String[] getArray(String key) { return getArray(key, Default.LIST_SEPARATOR); } Properlty(boolean caseSensitive, Map<String, PropertyValue> properties); static ProperltyBuilder builder(); Optional<String> get(String key); String get(String key, String defaultValue); Optional<T> get(String key, Function<String, T> map); T get(String key, T defaultValue, Function<String, T> map); Optional<Integer> getInt(String key); int getInt(String key, int defaultValue); Optional<Boolean> getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); Optional<Double> getDouble(String key); double getDouble(String key, double defaultValue); Optional<Float> getFloat(String key); float getFloat(String key, float defaultValue); Optional<Long> getLong(String key); long getLong(String key, long defaultValue); Optional<BigDecimal> getBigDecimal(String key); BigDecimal getBigDecimal(String key, BigDecimal defaultValue); Optional<BigInteger> getBigInteger(String key); BigInteger getBigInteger(String key, BigInteger defaultValue); Optional<T> getEnum(String key, Class<T> type); T getEnum(String key, T defaultValue); String[] getArray(String key); String[] getArray(String key, String separator); List<String> getList(String key); List<String> getList(String key, String separator); List<T> getList(String key, Function<String, T> map); List<T> getList(String key, String separator, Function<String, T> map); }### Answer:
@Test public void shouldReturnValueToArray() { final Map<String, String> properties = new HashMap<>(); properties.put("key.one", "111,AAAAA,BBB"); final Properlty prop = buildProperlty(properties); final String[] values = prop.getArray("key.one"); assertEquals(3, values.length); assertEquals("111", values[0]); assertEquals("AAAAA", values[1]); assertEquals("BBB", values[2]); assertEquals(0, prop.getArray("key.three").length); } |
### Question:
SystemPropertiesReader implements Reader { @Override public Map<String, PropertyValue> read() { final Map<String, PropertyValue> properties = new HashMap<>(); final Properties systemProperties = System.getProperties(); for(final Entry<Object, Object> x : systemProperties.entrySet()) { properties.put((String)x.getKey(), PropertyValue.of((String)x.getValue())); } return properties; } @Override Map<String, PropertyValue> read(); }### Answer:
@Test public void shouldReadSystemProperties() { final String key = UUID.randomUUID().toString(); final String value = UUID.randomUUID().toString(); System.setProperty(key, value); final Map<String, PropertyValue> systemProperties = new SystemPropertiesReader().read(); assertNotNull(systemProperties); assertTrue(systemProperties.containsKey(key)); assertEquals(value, systemProperties.get(key).getValue()); } |
### Question:
EnvironmentVariablesReader implements Reader { @Override public Map<String, PropertyValue> read() { return envSupplier.get().entrySet().stream() .collect(Collectors.toMap( e -> getKey(e.getKey()), e -> PropertyValue.of(e.getValue()).resolvable(false) )); } EnvironmentVariablesReader(); EnvironmentVariablesReader(Supplier<Map<String, String>> envSupplier); @Override Map<String, PropertyValue> read(); EnvironmentVariablesReader replace(String from, String to); }### Answer:
@Test public void shouldReturnUnresolvableEnvironmentVariables() { final Map<String, PropertyValue> var = new EnvironmentVariablesReader().read(); assertNotNull(var); assertFalse(var.isEmpty()); var.forEach((key, value) -> { assertFalse(value.isResolvable()); }); } |
### Question:
PriorityQueueDecoratorReader implements Reader { @Override public Map<String, PropertyValue> read() { final Map<String, PropertyValue> result = new LinkedHashMap<>(); readersMap.forEach((priority, readers) -> { readers.forEach(reader -> { final Map<String, PropertyValue> entries = reader.read(); result.putAll(entries); }); }) ; return result; } @Override Map<String, PropertyValue> read(); void add(Reader reader, int priority); }### Answer:
@Test public void shouldReturnEmptyMapIfEmpty() { final PriorityQueueDecoratorReader queue = new PriorityQueueDecoratorReader(); final Map<String, PropertyValue> prop = queue.read(); assertNotNull(prop); assertTrue(prop.isEmpty()); } |
### Question:
AbstractMinikubeMojo extends AbstractMojo { @VisibleForTesting List<String> buildMinikubeCommand() { List<String> execString = new ArrayList<>(); execString.add(minikube); execString.add(getCommand()); if (flags != null) { execString.addAll(flags); } execString.addAll(getMoreFlags()); return execString; } @Override void execute(); }### Answer:
@Test public void testBuildMinikubeCommand() { spyAbstractMinikubeMojo.setMinikube("path/to/minikube"); spyAbstractMinikubeMojo.setFlags(ImmutableList.of("someFlag1", "someFlag2")); Mockito.when(spyAbstractMinikubeMojo.getCommand()).thenReturn("somecommand"); Mockito.when(spyAbstractMinikubeMojo.getMoreFlags()) .thenReturn(ImmutableList.of("moreFlag1", "moreFlag2")); Assert.assertEquals( Arrays.asList( "path/to/minikube", "somecommand", "someFlag1", "someFlag2", "moreFlag1", "moreFlag2"), spyAbstractMinikubeMojo.buildMinikubeCommand()); } |
### Question:
AbstractMinikubeMojo extends AbstractMojo { @Override public void execute() throws MojoExecutionException { List<String> minikubeCommand = buildMinikubeCommand(); try { commandExecutorSupplier.get().setLogger(mavenBuildLogger).run(minikubeCommand); } catch (InterruptedException | IOException ex) { throw new MojoExecutionException(getDescription() + " failed", ex); } } @Override void execute(); }### Answer:
@Test public void testExecute() throws IOException, MojoExecutionException, InterruptedException { List<String> minikubeCommand = Arrays.asList("some", "command"); Mockito.doReturn(minikubeCommand).when(spyAbstractMinikubeMojo).buildMinikubeCommand(); spyAbstractMinikubeMojo.setCommandExecutorSupplier(() -> mockCommandExecutor); spyAbstractMinikubeMojo.setMavenBuildLogger(mockMavenBuildLogger); spyAbstractMinikubeMojo.execute(); Mockito.verify(mockCommandExecutor).setLogger(mockMavenBuildLogger); Mockito.verify(mockCommandExecutor).run(minikubeCommand); } |
### Question:
CommandExecutor { public List<String> run(String... command) throws IOException, InterruptedException { return run(Arrays.asList(command)); } CommandExecutor setLogger(BuildLogger logger); CommandExecutor setEnvironment(Map<String, String> environmentMap); List<String> run(String... command); List<String> run(List<String> command); }### Answer:
@Test public void testRun_success() throws IOException, InterruptedException { setMockProcessOutput(expectedOutput); List<String> output = testCommandExecutor.run(command); verifyProcessBuilding(command); Assert.assertEquals(expectedOutput, output); Mockito.verifyZeroInteractions(mockBuildLogger); }
@Test public void testRun_commandError() throws InterruptedException, IOException { setMockProcessOutput(expectedOutput); Mockito.when(mockProcess.waitFor()).thenReturn(1); try { testCommandExecutor.run(command); Assert.fail("Expected an IOException to be thrown"); } catch (IOException ex) { Assert.assertEquals("command exited with non-zero exit code : 1", ex.getMessage()); verifyProcessBuilding(command); Mockito.verifyZeroInteractions(mockBuildLogger); } } |
### Question:
MinikubeExtension { public Map<String, String> getDockerEnv() throws IOException, InterruptedException { return getDockerEnv(""); } MinikubeExtension(Project project, CommandExecutorFactory commandExecutorFactory); String getMinikube(); void setMinikube(String minikube); Property<String> getMinikubeProvider(); Map<String, String> getDockerEnv(); Map<String, String> getDockerEnv(String profile); }### Answer:
@Test public void testGetDockerEnvWithDefaultProfile() throws IOException, InterruptedException { expectedCommand.add("--profile="); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(expectedMap, minikube.getDockerEnv()); verify(commandExecutorMock).run(expectedCommand); }
@Test public void testGetDockerEnvWithTestProfile() throws IOException, InterruptedException { String profile = "testProfile"; expectedCommand.add("--profile=".concat(profile)); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(expectedMap, minikube.getDockerEnv(profile)); verify(commandExecutorMock).run(expectedCommand); }
@Test public void testGetSameDockerEnvWithTwoDefaultProfiles() throws IOException, InterruptedException { String profile = ""; expectedCommand.add("--profile=".concat(profile)); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(minikube.getDockerEnv(), minikube.getDockerEnv(profile)); verify(commandExecutorMock, times(2)).run(expectedCommand); }
@Test public void testGetDockerEnvWithNullProfile() throws IOException, InterruptedException { try { minikube.getDockerEnv(null); Assert.fail("getDockerEnv() should not permit null values"); } catch (NullPointerException ex) { Assert.assertNotNull(ex.getMessage()); Assert.assertEquals("Minikube profile must not be null", ex.getMessage()); } } |
### Question:
DefaultedURL { @Override public boolean equals(Object o) { if (o instanceof DefaultedURL) { return url.equals(((DefaultedURL) o).getUrl()); } return false; } DefaultedURL(); boolean isDefault(); void setUrl(URL url); String getDomain(); URL getUrl(); @Override String toString(); @Override boolean equals(Object o); }### Answer:
@Test public void testEquals_true() throws MalformedURLException { DefaultedURL defaultedURL = new DefaultedURL(); DefaultedURL customURL = new DefaultedURL(); assertTrue(defaultedURL.equals(customURL)); } |
### Question:
GatewaysManager { public int size() { return gateways.size(); } GatewaysManager(Context context); Gateway select(int nClosest); int getPosition(VpnProfile profile); boolean isEmpty(); int size(); @Override String toString(); }### Answer:
@Test public void testGatewayManagerFromCurrentProvider_noProvider_noGateways() { MockHelper.mockProviderObserver(null); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(0, gatewaysManager.size()); }
@Test public void testGatewayManagerFromCurrentProvider_misconfiguredProvider_noGateways() throws IOException, NullPointerException { Provider provider = getProvider(null, null, null, null, null, null, "ptdemo_misconfigured_gateway.json", null); MockHelper.mockProviderObserver(provider); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(0, gatewaysManager.size()); }
@Test public void testGatewayManagerFromCurrentProvider_threeGateways() { Provider provider = getProvider(null, null, null, null,null, null, "ptdemo_three_mixed_gateways.json", null); MockHelper.mockProviderObserver(provider); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(3, gatewaysManager.size()); } |
### Question:
GatewaySelector { public Gateway select() { return closestGateway(); } GatewaySelector(List<Gateway> gateways); Gateway select(); Gateway select(int nClosest); }### Answer:
@Test @UseDataProvider("dataProviderTimezones") public void testSelect(int timezone, String expected) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); assertEquals(expected, gatewaySelector.select().getName()); }
@Test @UseDataProvider("dataProviderSameDistanceTimezones") public void testSelectSameTimezoneDistance(int timezone, String expected1, String expected2) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); assertTrue(gatewaySelector.select().getName().equals(expected1) || gatewaySelector.select().getName().equals(expected2)); }
@Test @UseDataProvider("dataProviderSameDistanceTimezones") public void testNClostest_SameTimezoneDistance_chooseGatewayWithSameDistance(int timezone, String expected1, String expected2) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); ArrayList<String> gateways = new ArrayList<>(); gateways.add(gatewaySelector.select(0).getName()); gateways.add(gatewaySelector.select(1).getName()); assertTrue(gateways.contains(expected1) && gateways.contains(expected2)); }
@Test public void testNClostest_OneTimezonePerSet_choseSecondClosestTimezone() { when(ConfigHelper.getCurrentTimezone()).thenReturn(-4); gatewaySelector = new GatewaySelector(gatewayList); assertTrue("Frankfurt".equals(gatewaySelector.select(1).getName())); } |
### Question:
CeSymmMain { public static List<String> parseInputStructures(String filename) throws FileNotFoundException { File file = new File(filename); Scanner s = new Scanner(file); List<String> structures = new ArrayList<String>(); while (s.hasNext()) { String name = s.next(); if (name.startsWith("#")) { s.nextLine(); } else { structures.add(name); } } s.close(); return structures; } static void main(String[] args); static List<String> parseInputStructures(String filename); }### Answer:
@Test public void testParseInput() throws FileNotFoundException { URL url = CeSymmMainTest.class.getResource("/cesymmtest.txt"); String filename = url.getFile(); List<String> names = CeSymmMain.parseInputStructures(filename); assertEquals(6,names.size()); int i = 0; assertEquals("d1ijqa1",names.get(i++)); assertEquals("1G6S",names.get(i++)); assertEquals("1MER.A",names.get(i++)); assertEquals("d1h70a_",names.get(i++)); assertEquals("2YMS_A:,C:,B:,D:",names.get(i++)); assertEquals("1HIV",names.get(i++)); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public List<StringSecretEntry> getAllStringSecrets() { return secretsGroup.getLatestActiveVersionOfAllSecrets() .stream() .filter(secretEntry -> secretEntry.secretValue.encoding == Encoding.UTF8) .map(StringSecretEntry::of) .collect(Collectors.toList()); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getAllStringSecrets() { List<StringSecretEntry> secrets = simpleSecretsGroup.getAllStringSecrets(); StringSecretEntry one = new StringSecretEntry(stringSecretIdentifier2, 1l, stringSecretValue2.asString()); StringSecretEntry two = new StringSecretEntry(stringSecretIdentifier3, 1l, stringSecretValue3.asString()); assertThat(secrets, is(Arrays.asList(one, two))); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public List<ByteSecretEntry> getAllBinarySecrets() { return secretsGroup.getLatestActiveVersionOfAllSecrets() .stream() .filter(secretEntry -> secretEntry.secretValue.encoding == Encoding.BINARY) .map(ByteSecretEntry::of) .collect(Collectors.toList()); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getAllByteSecrets() { List<ByteSecretEntry> secrets = simpleSecretsGroup.getAllBinarySecrets(); ByteSecretEntry one = new ByteSecretEntry(binarySecretIdentifier2, 1l, binarySecretValue2.asByteArray()); ByteSecretEntry two = new ByteSecretEntry(binarySecretIdentifier3, 1l, binarySecretValue3.asByteArray()); assertThat(secrets, is(Arrays.asList(one, two))); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public Optional<String> getStringSecret(final SecretIdentifier secretIdentifier) { return asString(secretsGroup.getLatestActiveVersion(secretIdentifier)); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(stringSecretIdentifier); assertThat(result, is(Optional.of(value1))); }
@Test public void versioned_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(stringSecretIdentifier, version); assertThat(result, is(Optional.of(value2))); }
@Test public void not_present_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(notPresent); assertThat(result, is(Optional.empty())); }
@Test public void not_present_versioned_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(notPresent, version); assertThat(result, is(Optional.empty())); }
@Test(expectedExceptions = EncodingException.class) public void getStringSecret_on_binary_secret() { simpleSecretsGroup.getStringSecret(binarySecretIdentifier); } |
### Question:
IAMPolicyManager { public void detachReadOnly(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group,principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDetachReadonlyRole() throws Exception { Principal principal = new Principal(PrincipalType.ROLE, "awesome-service"); partiallyMockedPolicyManager.detachReadOnly(group, principal); DetachRolePolicyRequest request = new DetachRolePolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withRoleName(principal.name); verify(mockClient, times(1)).detachRolePolicy(request); } |
### Question:
IAMPolicyManager { public void detachAllPrincipals(SecretsGroupIdentifier group) { try { List<Principal> admins = listAttachedAdmin(group); admins.forEach(p -> detachAdmin(group, p)); } catch (DoesNotExistException e) { } try { List<Principal> readonly = listAttachedReadOnly(group); readonly.forEach(p -> detachReadOnly(group, p)); } catch (DoesNotExistException e) { } } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDetachAllPrincipals() throws Exception { } |
### Question:
IAMPolicyManager { public void deleteAdminPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDeleteAdminPolicy() throws Exception { DeletePolicyRequest request = new DeletePolicyRequest().withPolicyArn(ADMIN_POLICY_ARN); partiallyMockedPolicyManager.deleteAdminPolicy(group); verify(mockClient, times(1)).deletePolicy(request); } |
### Question:
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDeleteReadonlyPolicy() throws Exception { DeletePolicyRequest request = new DeletePolicyRequest().withPolicyArn(READONLY_POLICY_ARN); partiallyMockedPolicyManager.deleteReadonlyPolicy(group); verify(mockClient, times(1)).deletePolicy(request); } |
### Question:
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testToString() throws Exception { assertEquals(resourceName.toString(), resourceAsString); } |
### Question:
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testFromString() throws Exception { assertEquals(RegionLocalResourceName.fromString(resourceAsString).group, resourceName.group); assertEquals(RegionLocalResourceName.fromString(resourceAsString).toString(), resourceAsString); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringInvalidPrefix() throws Exception { RegionLocalResourceName.fromString("sm_us-west-1_test-group"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringMissingRegion() throws Exception { RegionLocalResourceName.fromString("strongbox_test-group"); } |
### Question:
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testEquals() { assertTrue(resourceName.equals(resourceName)); assertTrue(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2")))); assertFalse(resourceName.equals(resourceAsString)); } |
### Question:
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } SessionCache(final ProfileIdentifier profile, final RoleARN roleToAssume); Optional<BasicSessionCredentials> load(); void save(final AssumedRoleUser assumedRoleUser, final BasicSessionCredentials credentials, final ZonedDateTime expiration); }### Answer:
@Test public void resolve_filename() { ProfileIdentifier profile = new ProfileIdentifier("my-profile"); RoleARN arn = new RoleARN("arn:aws:iam::12345678910:role/my-role"); SessionCache sessionCache = new SessionCache(profile, arn); assertThat(sessionCache.resolveFileName(), is("my-profile--arn_aws_iam__12345678910_role-my-role.json")); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testEncrypt() throws Exception { String plaintext = "jsonblob"; EncryptionContext mockContext = mock(EncryptionContext.class); CryptoResult mockCryptoResult = mock(CryptoResult.class); Map<String, String> contextMap = new HashMap<>(); when(mockContext.toMap()).thenReturn(contextMap); when(mockCryptoResult.getResult()).thenReturn(encryptedPayload); when(mockAwsCrypto.encryptString(mockProvider, plaintext, contextMap)).thenReturn( mockCryptoResult); assertEquals(kmsEncryptor.encrypt(plaintext, mockContext), encryptedPayload); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testCreate() throws Exception { when(mockKmsManager.create()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.create(), KMS_ARN); verify(mockKmsManager, times(1)).create(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testDelete() throws Exception { kmsEncryptor.delete(); verify(mockKmsManager, times(1)).delete(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testAwsAdminPolicy() throws Exception { String adminPolicy = "Admin policy"; when(mockKmsManager.awsAdminPolicy()).thenReturn(Optional.of(adminPolicy)); assertEquals(kmsEncryptor.awsAdminPolicy().get(),adminPolicy); verify(mockKmsManager, times(1)).awsAdminPolicy(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testAwsReadOnlyPolicy() throws Exception { String readonlyPolicy = "Readonly policy"; when(mockKmsManager.awsReadOnlyPolicy()).thenReturn(Optional.of(readonlyPolicy)); assertEquals(kmsEncryptor.awsReadOnlyPolicy().get(), readonlyPolicy); verify(mockKmsManager, times(1)).awsReadOnlyPolicy(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testGetArn() throws Exception { when(mockKmsManager.getArn()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.getArn(), KMS_ARN); verify(mockKmsManager, times(1)).getArn(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testExists() throws Exception { when(mockKmsManager.exists()).thenReturn(true); assertTrue(kmsEncryptor.exists()); verify(mockKmsManager, times(1)).exists(); } |
### Question:
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testGetAdminPolicyArn() throws Exception { String arn = partiallyMockedPolicyManager.getAdminPolicyArn(group); assertEquals(arn, ADMIN_POLICY_ARN); } |
### Question:
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testDelete() throws Exception { ScheduleKeyDeletionRequest deleteRequest = new ScheduleKeyDeletionRequest() .withKeyId(KMS_ARN) .withPendingWindowInDays(7); ScheduleKeyDeletionResult deleteResult = new ScheduleKeyDeletionResult(). withDeletionDate(new Date()); when(mockKMSClient.scheduleKeyDeletion(deleteRequest)).thenReturn(deleteResult); when(mockKMSClient.describeKey(describeKeyRequest)) .thenReturn(enabledKeyResult()) .thenReturn(enabledKeyResult()) .thenReturn(constructDescribeKeyResult(KeyState.PendingDeletion)); kmsManager.delete(); verify(mockKMSClient, times(3)).describeKey(describeKeyRequest); verify(mockKMSClient, times(1)).scheduleKeyDeletion(deleteRequest); } |
### Question:
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testExists() throws Exception { when(mockKMSClient.describeKey(describeKeyRequest)).thenReturn(enabledKeyResult()); assertTrue(kmsManager.exists()); } |
### Question:
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test(enabled = false) public void testSerialize() { String serialized = encryptionPayload.toJsonBlob(); assertThat(serialized, is(blob)); } |
### Question:
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test(enabled = false) public void testDeserialize() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob(blob); assertThat(deserialized, is(encryptionPayload)); }
@Test(expectedExceptions = ParseException.class) public void testDeserializeInvalidJson() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob("{!@#$%^"); } |
### Question:
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test public void testToString() { assertEquals( encryptionPayload.toString(), "EncryptionPayload{value=SecretValue{type=opaque, secretEncoding=utf8}, userdata=Optional[UserData{}], " + "created=2016-06-01T00:00Z[UTC], modified=2017-06-01T00:00Z[UTC], " + "comment=Optional[Comment{}]}"); } |
### Question:
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test public void ensureNotCommutative() { byte[] sha1 = EncryptionPayload.computeSHA(State.ENABLED, notAfter, Optional.empty()); byte[] sha2 = EncryptionPayload.computeSHA(State.ENABLED, Optional.empty(), notAfter); assertNotEquals(sha1, sha2, "Should not be able to reorder and have the same hash"); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.